Total Derivative Ontology

flow "TotalDerivativeOntology" v1.0

# ============================================================
# TOTAL DERIVATIVE ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
TOTAL_DERIVATIVE := {
    type: MathematicalDerivative,
    domain: MultivariableCalculus,
    purpose: "Represent the complete first-order linear change of a multivariable function with respect to simultaneous changes in all relevant input variables."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    MULTIVARIABLE_FUNCTION,
    PARTIAL_DERIVATIVE,
    TOTAL_DERIVATIVE,
    TOTAL_DIFFERENTIAL,
    DIFFERENTIABILITY,
    LINEAR_MAP,
    JACOBIAN,
    GRADIENT,
    CHAIN_RULE,
    DIRECTIONAL_DERIVATIVE,
    INCREMENT,
    LOCAL_LINEARISATION
}

# ---------- FUNCTION STRUCTURE ----------
FUNCTION
    := F: R^n -> R^m

INPUT_VECTOR
    := x = (x1, x2, ..., xn)

OUTPUT_VECTOR
    := F(x)

TOTAL_DERIVATIVE
    -> describes(FULL_FIRST_ORDER_RESPONSE_OF_OUTPUT_TO_INPUT_CHANGE)

# ---------- FRECHET DERIVATIVE FORM ----------
TOTAL_DERIVATIVE_AT(F, a)
    := LINEAR_MAP A

such_that

limit(
    norm(F(a+h)-F(a)-A(h)) / norm(h),
    h -> 0
) = 0

A
    -> unique_when_exists

A
    -> denoted(DF(a))

TOTAL_DERIVATIVE
    -> best_linear_approximation_of(F_NEAR_a)

# ---------- LOCAL LINEARISATION ----------
F(a+h)
    = F(a)
    + DF(a)[h]
    + r(h)

where

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

LOCAL_LINEARISATION
    -> determined_by(TOTAL_DERIVATIVE)

# ---------- SCALAR-VALUED FUNCTION ----------
for
    f: R^n -> R

TOTAL_DERIVATIVE
    -> linear_functional

Df(a)[h]
    = gradient(f)(a) dot h

GRADIENT
    -> coordinate_representation_of(TOTAL_DERIVATIVE)
       in(EUCLIDEAN_SCALAR_CONTEXT)

# ---------- TOTAL DIFFERENTIAL ----------
for
    z = f(x1, x2, ..., xn)

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

TOTAL_DIFFERENTIAL
    -> represents(FIRST_ORDER_OUTPUT_CHANGE)

delta_z
    ~= dz
       for(SUFFICIENTLY_SMALL_INPUT_CHANGES)

# ---------- PARTIAL DERIVATIVE RELATION ----------
PARTIAL_DERIVATIVE
    -> measures(CHANGE_ALONG_ONE_COORDINATE_DIRECTION)

TOTAL_DERIVATIVE
    -> combines(ALL_FIRST_ORDER_COORDINATE_RESPONSES)

if
    TOTAL_DERIVATIVE_EXISTS
then
    relevant_partial_derivatives
        -> exist

EXISTENCE_OF_ALL_PARTIAL_DERIVATIVES
    -/> necessarily_implies(TOTAL_DIFFERENTIABILITY)

# ---------- JACOBIAN ----------
for
    F: R^n -> R^m

JACOBIAN(F)
    := matrix(
        partial_F_i/partial_x_j
    )

if
    F totally_differentiable_at(a)
then
    JACOBIAN(F)(a)
        -> matrix_representation_of(DF(a))
           in(STANDARD_COORDINATES)

TOTAL_DERIVATIVE
    -> represented_by(JACOBIAN)
       in(FINITE_DIMENSIONAL_COORDINATE_CONTEXT)

# ---------- DIFFERENTIABILITY ----------
TOTAL_DIFFERENTIABILITY_AT(F, a)
    iff
    TOTAL_DERIVATIVE_AT(F, a) exists

TOTAL_DIFFERENTIABILITY
    -> implies(CONTINUITY_AT_POINT)

TOTAL_DIFFERENTIABILITY
    -> implies(EXISTENCE_OF_PARTIAL_DERIVATIVES)

PARTIAL_DERIVATIVES_CONTINUOUS_NEAR_POINT
    -> sufficient_condition_for(TOTAL_DIFFERENTIABILITY)
       under(standard_finite_dimensional_conditions)

# ---------- DIRECTIONAL DERIVATIVE ----------
if
    F totally_differentiable_at(a)
then
    D_u F(a)
        = DF(a)[u]

for scalar f:
    D_u f(a)
        = gradient(f)(a) dot u

TOTAL_DERIVATIVE
    -> determines(ALL_DIRECTIONAL_DERIVATIVES)
       when(it_exists)

EXISTENCE_OF_ALL_DIRECTIONAL_DERIVATIVES
    -/> necessarily_implies(TOTAL_DIFFERENTIABILITY)

# ---------- CHAIN RULE ----------
if
    F: R^n -> R^m
    AND G: R^m -> R^p
    AND F differentiable_at(a)
    AND G differentiable_at(F(a))
then

D(G composed_with F)(a)
    = DG(F(a)) composed_with DF(a)

CHAIN_RULE
    -> composes(TOTAL_DERIVATIVES)

in_matrix_form:
    J_(G∘F)(a)
        = J_G(F(a)) * J_F(a)

# ---------- DEPENDENT VARIABLES ----------
if
    z = f(x,y)
    AND x = x(t)
    AND y = y(t)
then

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

TOTAL_DERIVATIVE
    -> accounts_for(ALL_DEPENDENCY_PATHS)

# ---------- ERROR STRUCTURE ----------
LINEAR_APPROXIMATION_ERROR
    := F(a+h)-F(a)-DF(a)[h]

TOTAL_DIFFERENTIABILITY
    -> requires(
        ERROR_IS_SMALLER_ORDER_THAN_norm(h)
    )

ERROR_RATIO
    := norm(error)/norm(h)

h -> 0
    -> ERROR_RATIO -> 0

# ---------- COORDINATE CHANGE ----------
TOTAL_DERIVATIVE
    -> intrinsic_linear_map

JACOBIAN_MATRIX
    -> coordinate_representation_of(TOTAL_DERIVATIVE)

COORDINATE_CHANGE
    -> changes(MATRIX_REPRESENTATION)
    -/> changes(UNDERLYING_LINEAR_MAP)

# ---------- APPLICATIONS ----------
TOTAL_DERIVATIVE
    -> applied_to(MULTIVARIABLE_APPROXIMATION)
    -> applied_to(SENSITIVITY_ANALYSIS)
    -> applied_to(OPTIMISATION)
    -> applied_to(NONLINEAR_SYSTEMS)
    -> applied_to(DIFFERENTIAL_EQUATIONS)
    -> applied_to(COORDINATE_TRANSFORMATIONS)

# ---------- RELATION GRAPH ----------
PARTIAL_DERIVATIVES
    -> provide(COORDINATE_COMPONENTS)

TOTAL_DERIVATIVE
    -> integrates(FIRST_ORDER_COMPONENTS)

TOTAL_DERIVATIVE
    -> represented_by(JACOBIAN)

TOTAL_DERIVATIVE
    -> determines(LOCAL_LINEARISATION)

TOTAL_DERIVATIVE
    -> determines(DIRECTIONAL_DERIVATIVES)

CHAIN_RULE
    -> composes(TOTAL_DERIVATIVES)

TOTAL_DIFFERENTIABILITY
    -> implies(CONTINUITY)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "total derivative" ~= "best first-order linear map approximating a multivariable function",
    "total differential" ~= "first-order output change generated by the total derivative",
    "Jacobian" ~= "matrix representation of the total derivative in finite-dimensional coordinates",
    "full derivative" ~= "total derivative in multivariable context",
    "linearisation" ~= "local affine approximation constructed from the total derivative"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    total_derivative_is_linear_map: true,
    total_differentiability_implies_continuity: true,
    total_differentiability_implies_partial_derivatives_exist: true,
    partial_derivatives_alone_do_not_guarantee_total_differentiability: true,
    directional_derivatives_alone_do_not_guarantee_total_differentiability: true,
    jacobian_is_coordinate_representation_not_the_abstract_map_itself: true,
    chain_rule_requires_differentiability_conditions: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    core_definition: 0.99,
    linearisation_relation: 0.99,
    partial_derivative_relation: 0.99,
    jacobian_relation: 0.99,
    directional_derivative_relation: 0.99,
    chain_rule_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(function)
    -> determine(input_and_output_spaces)
    -> identify(point_of_differentiation)
    -> derive_or_identify(partial_derivatives)
    -> test(total_differentiability)
    -> construct(linear_map)
    -> represent_as(jacobian_if_coordinates_used)
    -> evaluate(local_linearisation)
    -> trace(all_dependency_paths)
    -> apply(chain_rule_if_composed)
    -> validate(error_order_condition)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed total-derivative semantic graph",
    primary_entity: TOTAL_DERIVATIVE,
    preserve: [
        input_output_spaces,
        linear_map_structure,
        approximation_error_condition,
        coordinate_representation,
        dependency_paths,
        differentiability_conditions
    ],
    infer_through: [
        partial_derivatives,
        gradients,
        jacobians,
        directional_derivatives,
        linearisations,
        chain_rules
    ],
    avoid: [
        equating_existence_of_partials_with_total_differentiability,
        equating_all_directional_derivatives_with_total_differentiability,
        confusing_jacobian_matrix_with_abstract_derivative_map,
        omitting_indirect_dependency_paths,
        applying_chain_rule_without differentiability conditions
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + TOTAL_DERIVATIVE
    + TOTAL_DIFFERENTIAL
    + LOCAL_LINEARISATION
    + PARTIAL_DERIVATIVE
    + JACOBIAN
    + DIRECTIONAL_DERIVATIVE
    + CHAIN_RULE
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> TOTAL_DERIVATIVE
    -> FUNCTION_SPACE_IDENTIFICATION
    -> POINT_IDENTIFICATION
    -> PARTIAL_DERIVATIVE_ANALYSIS
    -> TOTAL_DIFFERENTIABILITY_ANALYSIS
    -> LINEAR_MAP_CONSTRUCTION
    -> JACOBIAN_ANALYSIS
    -> DIRECTIONAL_DERIVATIVE_ANALYSIS
    -> DEPENDENCY_PATH_ANALYSIS
    -> CHAIN_RULE_ANALYSIS
    -> LOCAL_ERROR_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW