Differential Ontology

flow "DifferentialOntology" v1.0

# ============================================================
# DIFFERENTIAL ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/differential-calculus/differential-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Differential Calculus"
ENTITY := "Differential"

# ---------- CORE ENTITY ----------
DIFFERENTIAL := {
    type: MathematicalLinearApproximation,
    domain: DifferentialCalculus,
    purpose: "Represent the first-order linear change in a dependent quantity induced by a small change in one or more independent variables."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    DIFFERENTIAL,
    DERIVATIVE,
    INDEPENDENT_VARIABLE,
    DEPENDENT_VARIABLE,
    INCREMENT,
    LOCAL_LINEARISATION,
    TOTAL_DIFFERENTIAL,
    PARTIAL_DERIVATIVE,
    TOTAL_DERIVATIVE,
    ERROR_TERM,
    DIFFERENTIAL_FORM,
    CHAIN_RULE
}

# ---------- SINGLE-VARIABLE STRUCTURE ----------
if
    y = f(x)
    AND f differentiable_at(x)
then

dy
    := f_prime(x) * dx

DIFFERENTIAL
    -> linear_in(dx)
    -> determined_by(DERIVATIVE)

dx
    -> differential_of(INDEPENDENT_VARIABLE)

dy
    -> differential_of(DEPENDENT_VARIABLE)

# ---------- INCREMENT RELATION ----------
ACTUAL_INCREMENT
    := delta_y
    = f(x + delta_x) - f(x)

LINEAR_INCREMENT
    := dy
    = f_prime(x) * delta_x

for sufficiently small delta_x:

delta_y
    = dy + higher_order_error

and

delta_y
    ~= dy

DIFFERENTIAL
    -> first_order_approximation_of(ACTUAL_CHANGE)

# ---------- DIFFERENTIABILITY FORM ----------
f(x+h)
    = f(x)
    + f_prime(x)*h
    + r(h)

where

r(h)/h
    -> 0
       as h -> 0

DIFFERENTIAL_TERM
    := f_prime(x)*h

DIFFERENTIABILITY
    -> decomposes_change_into(
        LINEAR_DIFFERENTIAL_TERM,
        SMALLER_ORDER_ERROR
    )

# ---------- DERIVATIVE RELATION ----------
DERIVATIVE
    := dy/dx
       in(standard_single_variable_notation)

dy
    = derivative * dx

DERIVATIVE
    -> coefficient_of(LINEAR_DIFFERENTIAL)

DIFFERENTIAL
    -> applies(DERIVATIVE_TO_INPUT_CHANGE)

# ---------- LOCAL LINEARISATION ----------
LINEARISATION_AT_a
    := f(a) + f_prime(a)*(x-a)

if
    dx = x-a
then

dy
    = f_prime(a)*dx

LOCAL_LINEARISATION
    -> constructed_from(DIFFERENTIAL)

# ---------- MULTIVARIABLE TOTAL DIFFERENTIAL ----------
if
    z = f(x1, x2, ..., xn)
    AND f totally_differentiable
then

dz
    = sum(
        partial_f/partial_x_i * dx_i,
        i=1..n
    )

TOTAL_DIFFERENTIAL
    -> combines(ALL_FIRST_ORDER_PARTIAL_CHANGES)

# ---------- TWO-VARIABLE FORM ----------
if
    z = f(x,y)
then

dz
    = partial_f/partial_x * dx
    + partial_f/partial_y * dy

TOTAL_DIFFERENTIAL
    -> approximates(delta_z)
       for(SMALL_INPUT_CHANGES)

# ---------- TOTAL DERIVATIVE RELATION ----------
TOTAL_DERIVATIVE
    -> linear_map

DIFFERENTIAL
    -> application_of(TOTAL_DERIVATIVE_TO_INCREMENT)

for
    F: R^n -> R^m

dF
    := DF(x)[dx]

TOTAL_DIFFERENTIAL
    -> coordinate_expression_of(TOTAL_DERIVATIVE_ACTION)

# ---------- CHAIN RULE ----------
if
    y = f(u)
    AND u = g(x)
then

dy
    = f_prime(u) * du

du
    = g_prime(x) * dx

therefore

dy
    = f_prime(g(x))
      * g_prime(x)
      * dx

DIFFERENTIAL_CHAIN_RULE
    -> propagates(FIRST_ORDER_CHANGE_THROUGH_COMPOSITION)

# ---------- PRODUCT RULE ----------
d(fg)
    = f*dg + g*df

PRODUCT_DIFFERENTIAL
    -> follows_from(PRODUCT_RULE)

# ---------- QUOTIENT RULE ----------
if
    g != 0
then

d(f/g)
    = (g*df - f*dg)/g^2

QUOTIENT_DIFFERENTIAL
    -> follows_from(QUOTIENT_RULE)

# ---------- ERROR PROPAGATION ----------
if
    y = f(x1,...,xn)
then

dy
    = sum(
        partial_f/partial_x_i * dx_i
    )

DIFFERENTIAL
    -> supports(FIRST_ORDER_ERROR_PROPAGATION)

APPROXIMATE_ABSOLUTE_ERROR
    -> may_be_estimated_from(DIFFERENTIAL_MAGNITUDES)

ERROR_PROPAGATION
    -> requires(CONTEXT_SPECIFIC_ASSUMPTIONS)

# ---------- RELATED RATES ----------
if
    variables_depend_on(time)
then

dx
    -> may_equal(dx/dt * dt)

dy
    -> may_equal(dy/dt * dt)

DIFFERENTIAL_RELATIONS
    -> connect(RELATED_RATES)

# ---------- DIFFERENTIAL EQUATIONS ----------
DIFFERENTIAL_EQUATION
    -> contains(DIFFERENTIALS_OR_DERIVATIVES)

example:
    dy = f(x,y) dx

DIFFERENTIAL_FORM
    -> may_represent(FIRST_ORDER_DIFFERENTIAL_EQUATION)

# ---------- DIFFERENTIAL FORMS ----------
DIFFERENTIAL_FORM
    -> generalises(DIFFERENTIAL_EXPRESSIONS)

ONE_FORM
    := sum(
        a_i(x) dx_i
    )

EXACT_DIFFERENTIAL
    -> arises_as(DIFFERENTIAL_OF_SCALAR_FUNCTION)
       under(appropriate_conditions)

DIFFERENTIAL
    -> connects_to(DIFFERENTIAL_GEOMETRY)

# ---------- PHYSICAL INTERPRETATION ----------
if
    s = position
then

ds
    -> infinitesimal_or_first_order_position_change_in_formal_context

if
    V = volume(x,y,z)
then

dV
    -> first_order_change_in_volume

DIFFERENTIAL
    -> used_to_model(SMALL_CHANGES)

# ---------- RELATION GRAPH ----------
DERIVATIVE
    -> determines(DIFFERENTIAL)

DIFFERENTIAL
    -> approximates(INCREMENT)

TOTAL_DERIVATIVE
    -> generates(TOTAL_DIFFERENTIAL)

PARTIAL_DERIVATIVES
    -> coefficients_of(TOTAL_DIFFERENTIAL)

CHAIN_RULE
    -> propagates(DIFFERENTIALS)

DIFFERENTIAL
    -> supports(ERROR_APPROXIMATION)

DIFFERENTIAL
    -> appears_in(DIFFERENTIAL_EQUATIONS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "differential" ~= "first-order linear change associated with a differentiable function",
    "dy" ~= "differential of the dependent variable in standard calculus notation",
    "dx" ~= "differential of the independent variable in standard calculus notation",
    "total differential" ~= "sum of first-order partial derivative contributions",
    "linear change" ~= "differential contribution under local linear approximation",
    "small change approximation" ~= "differential approximation when higher-order terms are negligible"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    differential_depends_on_differentiability_context: true,
    differential_is_not_generally_equal_to_finite_increment: true,
    differential_is_first_order_linear: true,
    total_differential_requires_all_relevant_variable_contributions: true,
    approximation_quality_depends_on_increment_size_and_regularity: true,
    error_propagation_requires_model_specific_assumptions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    derivative_relation: 0.99,
    increment_relation: 0.99,
    total_differential_relation: 0.99,
    chain_rule_relation: 0.99,
    error_approximation_relation: 0.98,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function)
    -> identify(independent_and_dependent_variables)
    -> determine(differentiability)
    -> identify(input_increment_or_differential)
    -> derive(relevant_derivatives)
    -> construct(single_or_total_differential)
    -> compare_with(actual_increment_if_required)
    -> estimate(first_order_error_if_required)
    -> propagate_through(dependencies_if_composite)
    -> validate(linearity_and_domain_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed differential semantic graph",
    primary_entity: DIFFERENTIAL,
    preserve: [
        variable_roles,
        derivative_coefficients,
        first_order_structure,
        total_differential_components,
        error_order,
        dependency_paths
    ],
    infer_through: [
        derivatives,
        total_derivatives,
        partial_derivatives,
        linearisations,
        chain_rules,
        error_propagation,
        differential_equations
    ],
    avoid: [
        equating_differential_with_arbitrary_finite_increment,
        omitting_multivariable_contributions,
        ignoring_higher_order_error,
        treating_dx_as_dimensionless_without context,
        applying_error_approximations_without assumptions
    ]
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL(new_information):
    validate(new_information)
    -> identify(differential_context)
    -> compare(existing_relations)
    -> preserve(first_order_and_linearity_invariants)
    -> update(affected_entities)
    -> update(affected_edges)
    -> recompute(CONFIDENCE)
    -> regenerate(FLOW_HASH)

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + DIFFERENTIAL
    + ACTUAL_INCREMENT
    + LOCAL_LINEARISATION
    + TOTAL_DIFFERENTIAL
    + TOTAL_DERIVATIVE
    + DIFFERENTIAL_CHAIN_RULE
    + DIFFERENTIAL_FORM
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> DIFFERENTIAL
    -> FUNCTION_IDENTIFICATION
    -> VARIABLE_IDENTIFICATION
    -> DIFFERENTIABILITY_ANALYSIS
    -> DERIVATIVE_ANALYSIS
    -> INPUT_CHANGE_ANALYSIS
    -> DIFFERENTIAL_CONSTRUCTION
    -> TOTAL_DIFFERENTIAL_ANALYSIS
    -> LOCAL_APPROXIMATION_ANALYSIS
    -> ERROR_ANALYSIS
    -> DEPENDENCY_PROPAGATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW