Jacobian Ontology

flow "JacobianOntology" v1.0

# ============================================================
# JACOBIAN ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
JACOBIAN := {
    type: DerivativeMatrix,
    domain: MultivariableCalculus,
    purpose: "Represent the first-order partial derivatives of a vector-valued multivariable function as a matrix, providing the coordinate representation of its total derivative."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    VECTOR_VALUED_FUNCTION,
    PARTIAL_DERIVATIVE,
    TOTAL_DERIVATIVE,
    JACOBIAN_MATRIX,
    JACOBIAN_DETERMINANT,
    LINEARISATION,
    CHAIN_RULE,
    COORDINATE_TRANSFORMATION,
    INVERSE_FUNCTION,
    GRADIENT,
    DIFFERENTIABILITY
}

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

F(x1,...,xn)
    := (
        F1(x1,...,xn),
        F2(x1,...,xn),
        ...,
        Fm(x1,...,xn)
    )

INPUT_DIMENSION
    := n

OUTPUT_DIMENSION
    := m

# ---------- JACOBIAN MATRIX ----------
JACOBIAN_MATRIX(F)
    := matrix(
        partial_F_i / partial_x_j
    )

MATRIX_SHAPE
    := m x n

row_i
    -> derivatives_of(OUTPUT_COMPONENT_F_i)

column_j
    -> response_to(INPUT_VARIABLE_x_j)

JACOBIAN
    -> collects(FIRST_ORDER_PARTIAL_DERIVATIVES)

# ---------- TOTAL DERIVATIVE ----------
if
    F totally_differentiable_at(a)
then

DF(a)
    -> linear_map(R^n -> R^m)

JACOBIAN_MATRIX(F)(a)
    -> matrix_representation_of(DF(a))
       in(STANDARD_COORDINATES)

F(a+h)
    = F(a)
    + J_F(a) * h
    + r(h)

where

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

JACOBIAN
    -> determines(FIRST_ORDER_LOCAL_LINEARISATION)

# ---------- SCALAR OUTPUT ----------
if
    f: R^n -> R
then

JACOBIAN(f)
    -> 1 x n row_matrix
       under(common_convention)

GRADIENT(f)
    -> n x 1 column_vector
       under(common_convention)

JACOBIAN(f)
    <-> transpose_relation(GRADIENT(f))
       depending_on(CONVENTION)

# ---------- SCALAR INPUT ----------
if
    F: R -> R^m
then

JACOBIAN(F)
    -> m x 1 column_matrix

JACOBIAN
    -> contains(DERIVATIVES_OF_EACH_OUTPUT_COMPONENT)

# ---------- CHAIN RULE ----------
if
    G: R^p -> R^n
    AND F: R^n -> R^m
    AND both_are_differentiable_at_required_points
then

J_(F composed_with G)(x)
    = J_F(G(x)) * J_G(x)

JACOBIAN_CHAIN_RULE
    -> matrix_representation_of(TOTAL_DERIVATIVE_CHAIN_RULE)

MATRIX_ORDER
    -> follows(FUNCTION_COMPOSITION_ORDER)

# ---------- JACOBIAN DETERMINANT ----------
if
    n = m
then

JACOBIAN_DETERMINANT
    := det(J_F)

JACOBIAN_DETERMINANT
    -> measures(LOCAL_SIGNED_VOLUME_SCALING)

abs(JACOBIAN_DETERMINANT)
    -> measures(LOCAL_VOLUME_SCALE_FACTOR)

det(J_F) != 0
    -> indicates(LOCALLY_INVERTIBLE_LINEARISATION)

# ---------- INVERSE FUNCTION RELATION ----------
if
    F: R^n -> R^n
    AND F continuously_differentiable_near(a)
    AND det(J_F(a)) != 0
then

F
    -> locally_invertible_near(a)

J_(F_inverse)(F(a))
    = [J_F(a)]^(-1)

INVERSE_FUNCTION_THEOREM
    -> connects(NONSINGULAR_JACOBIAN, LOCAL_INVERTIBILITY)

# ---------- COORDINATE TRANSFORMATIONS ----------
COORDINATE_TRANSFORMATION
    := T: u -> x

J_T
    -> describes(LOCAL_COORDINATE_STRETCHING_AND_ROTATION)

CHANGE_OF_VARIABLES
    -> uses(abs(det(J_T)))
       as(VOLUME_ELEMENT_SCALE_FACTOR)

JACOBIAN_DETERMINANT
    -> central_to(MULTIVARIABLE_INTEGRATION_TRANSFORMATIONS)

# ---------- SINGULARITY ----------
SQUARE_JACOBIAN
    -> singular_when(det(J)=0)

SINGULAR_JACOBIAN
    -> indicates(LOSS_OF_LOCAL_LINEAR_INVERTIBILITY)

det(J)=0
    -/> alone_determines(ALL_GLOBAL_FUNCTION_BEHAVIOUR)

RANK
    -> measures(DIMENSION_OF_LOCAL_LINEAR_IMAGE)

# ---------- RANK ----------
RANK(J_F)
    -> number_of(LINEARLY_INDEPENDENT_LOCAL_OUTPUT_DIRECTIONS)

FULL_RANK
    -> context_dependent_on(MINIMUM_OF_INPUT_OUTPUT_DIMENSIONS)

RANK_DEFICIENCY
    -> indicates(LOCAL_DEGENERACY_OF_LINEARISATION)

# ---------- IMPLICIT FUNCTION RELATION ----------
IMPLICIT_SYSTEM
    := F(x,y) = 0

JACOBIAN_WITH_RESPECT_TO_y
    -> if_invertible
       supports(IMPLICIT_FUNCTION_THEOREM)

Dy/Dx
    = -(J_y F)^(-1) * J_x F
       under(required_conditions)

# ---------- OPTIMISATION ----------
JACOBIAN
    -> used_in(NONLINEAR_LEAST_SQUARES)
    -> used_in(CONSTRAINT_ANALYSIS)
    -> used_in(NEWTON_METHODS)
    -> used_in(SENSITIVITY_ANALYSIS)

VECTOR_RESIDUAL_FUNCTION
    -> locally_approximated_by(JACOBIAN)

# ---------- DIFFERENTIAL EQUATIONS ----------
SYSTEM_OF_ODEs
    := x_prime = F(x)

J_F
    -> linearises(DYNAMICAL_SYSTEM_NEAR_STATE)

EIGENVALUES_OF_JACOBIAN
    -> support(LOCAL_STABILITY_ANALYSIS)
       around(EQUILIBRIA)
       under(appropriate_conditions)

# ---------- RELATION GRAPH ----------
PARTIAL_DERIVATIVES
    -> populate(JACOBIAN)

TOTAL_DERIVATIVE
    -> represented_by(JACOBIAN)

JACOBIAN
    -> determines(LOCAL_LINEARISATION)

JACOBIANS
    -> multiply_under(CHAIN_RULE)

JACOBIAN_DETERMINANT
    -> measures(LOCAL_VOLUME_SCALING)

NONSINGULAR_JACOBIAN
    -> supports(LOCAL_INVERTIBILITY)

JACOBIAN_RANK
    -> describes(LOCAL_LINEAR_DIMENSION)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "Jacobian" ~= "matrix of first-order partial derivatives of a vector-valued function",
    "Jacobian matrix" ~= "coordinate matrix representing the total derivative",
    "Jacobian determinant" ~= "determinant of a square Jacobian matrix",
    "nonsingular Jacobian" ~= "square Jacobian with nonzero determinant",
    "Jacobian rank" ~= "rank of the derivative matrix",
    "local linearisation matrix" ~= "Jacobian in finite-dimensional coordinates"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    jacobian_shape_is_output_dimension_by_input_dimension: true,
    jacobian_determinant_requires_square_matrix: true,
    nonzero_determinant_implies_local_invertibility_only_under_required_conditions: true,
    jacobian_is_coordinate_representation_of_total_derivative: true,
    chain_rule_matrix_order_must_be_preserved: true,
    determinant_zero_does_not_alone_determine_global_behaviour: true,
    gradient_jacobian_orientation_depends_on_convention: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    matrix_definition: 0.99,
    total_derivative_relation: 0.99,
    chain_rule_relation: 0.99,
    determinant_relation: 0.99,
    inverse_function_relation: 0.99,
    coordinate_transformation_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(vector_valued_function)
    -> determine(input_dimension)
    -> determine(output_dimension)
    -> derive(component_partial_derivatives)
    -> assemble(jacobian_matrix)
    -> evaluate(at_requested_point_if_given)
    -> determine(rank_if_required)
    -> calculate(determinant_if_square_and_required)
    -> analyse(local_linearisation)
    -> apply(chain_rule_if_composed)
    -> analyse(invertibility_or_coordinate_scaling_if_relevant)
    -> validate(differentiability_and_dimension_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed Jacobian semantic graph",
    primary_entity: JACOBIAN,
    preserve: [
        input_dimension,
        output_dimension,
        matrix_orientation,
        component_derivatives,
        composition_order,
        determinant_conditions,
        rank_information
    ],
    infer_through: [
        partial_derivatives,
        total_derivatives,
        chain_rules,
        inverse_function_theorem,
        coordinate_transformations,
        dynamical_systems,
        optimisation
    ],
    avoid: [
        transposing_jacobian_without_convention_reason,
        taking_determinant_of_nonsquare_jacobian,
        reversing_chain_rule_matrix_order,
        treating_nonzero_determinant_as_global_invertibility,
        confusing_jacobian_with_hessian,
        ignoring_rank_deficiency
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + JACOBIAN
    + JACOBIAN_MATRIX
    + TOTAL_DERIVATIVE
    + JACOBIAN_CHAIN_RULE
    + JACOBIAN_DETERMINANT
    + RANK
    + INVERSE_FUNCTION_THEOREM
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> JACOBIAN
    -> FUNCTION_IDENTIFICATION
    -> DIMENSION_ANALYSIS
    -> COMPONENT_PARTIAL_ANALYSIS
    -> MATRIX_CONSTRUCTION
    -> TOTAL_DERIVATIVE_RELATION_ANALYSIS
    -> RANK_ANALYSIS
    -> DETERMINANT_ANALYSIS
    -> CHAIN_RULE_ANALYSIS
    -> INVERTIBILITY_ANALYSIS
    -> COORDINATE_TRANSFORMATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW