Hessian Ontology

flow "HessianOntology" v1.0

# ============================================================
# HESSIAN ONTOLOGY — FLOW ALGEBRA
# ============================================================

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

# ---------- CORE ENTITY ----------
HESSIAN := {
    type: SecondOrderDerivativeMatrix,
    domain: MultivariableCalculus,
    purpose: "Represent the matrix of second-order partial derivatives of a scalar-valued multivariable function, encoding local curvature and second-order behaviour."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    SCALAR_FIELD,
    PARTIAL_DERIVATIVE,
    SECOND_PARTIAL_DERIVATIVE,
    MIXED_PARTIAL_DERIVATIVE,
    HESSIAN_MATRIX,
    GRADIENT,
    JACOBIAN,
    CURVATURE,
    CRITICAL_POINT,
    QUADRATIC_FORM,
    EIGENVALUE,
    POSITIVE_DEFINITE,
    NEGATIVE_DEFINITE,
    SADDLE_POINT
}

# ---------- FUNCTION STRUCTURE ----------
SCALAR_FIELD
    := f: R^n -> R

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

HESSIAN
    -> defined_from(SECOND_ORDER_PARTIAL_DERIVATIVES)

# ---------- HESSIAN MATRIX ----------
HESSIAN_MATRIX(f)
    := matrix(
        partial_squared_f /
        (partial_x_i partial_x_j)
    )

MATRIX_SHAPE
    := n x n

ENTRY(i,j)
    := partial_squared_f /
       (partial_x_i partial_x_j)

HESSIAN
    -> collects(SECOND_ORDER_LOCAL_INFORMATION)

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

HESSIAN(f)
    := [
        [f_xx, f_xy],
        [f_yx, f_yy]
    ]

DIAGONAL_ENTRIES
    -> PURE_SECOND_PARTIALS

OFF_DIAGONAL_ENTRIES
    -> MIXED_PARTIALS

# ---------- GRADIENT RELATION ----------
GRADIENT(f)
    := vector(
        partial_f/partial_x1,
        ...,
        partial_f/partial_xn
    )

HESSIAN(f)
    := JACOBIAN_OF_GRADIENT(f)
       under(standard_coordinate_convention)

GRADIENT
    -> FIRST_ORDER_INFORMATION

HESSIAN
    -> SECOND_ORDER_INFORMATION

# ---------- SYMMETRY ----------
if
    mixed_second_partials_are_continuous
    near(point)
then

partial_squared_f /
(partial_x_i partial_x_j)

    =

partial_squared_f /
(partial_x_j partial_x_i)

therefore

HESSIAN
    -> symmetric

HESSIAN_SYMMETRY
    -> associated_with(CLAIRAUT_SCHWARZ_THEOREM)

SYMMETRY
    -/> assumed_without(APPROPRIATE_REGULARITY)

# ---------- SECOND-ORDER TAYLOR APPROXIMATION ----------
for small displacement h:

f(a+h)
    ~= f(a)
       + GRADIENT(f)(a) dot h
       + 1/2 * h^T * HESSIAN(f)(a) * h

HESSIAN
    -> determines(SECOND_ORDER_QUADRATIC_TERM)

QUADRATIC_FORM
    := h^T * H * h

QUADRATIC_FORM
    -> describes(LOCAL_CURVATURE_BEHAVIOUR)

# ---------- CRITICAL POINTS ----------
CRITICAL_POINT
    -> often_satisfies(GRADIENT(f)=ZERO_VECTOR)

HESSIAN
    -> may_classify(NONDEGENERATE_CRITICAL_POINTS)

GRADIENT_ZERO
    -/> sufficient_for(EXTREMUM)

# ---------- POSITIVE DEFINITE ----------
if
    HESSIAN_AT_CRITICAL_POINT
        -> POSITIVE_DEFINITE
then

critical_point
    -> STRICT_LOCAL_MINIMUM
       under(standard_second_derivative_test_conditions)

POSITIVE_DEFINITE
    iff
    h^T H h > 0
    for_all(nonzero h)

# ---------- NEGATIVE DEFINITE ----------
if
    HESSIAN_AT_CRITICAL_POINT
        -> NEGATIVE_DEFINITE
then

critical_point
    -> STRICT_LOCAL_MAXIMUM
       under(standard_second_derivative_test_conditions)

NEGATIVE_DEFINITE
    iff
    h^T H h < 0
    for_all(nonzero h)

# ---------- INDEFINITE ----------
if
    HESSIAN_AT_CRITICAL_POINT
        -> INDEFINITE
then

critical_point
    -> SADDLE_POINT
       under(standard_second_derivative_test_conditions)

INDEFINITE
    -> quadratic_form_takes(BOTH_POSITIVE_AND_NEGATIVE_VALUES)

# ---------- SEMIDEFINITE / DEGENERATE ----------
POSITIVE_SEMIDEFINITE
    -> h^T H h >= 0

NEGATIVE_SEMIDEFINITE
    -> h^T H h <= 0

SEMIDEFINITE_HESSIAN
    -> second_derivative_test_may_be(INCONCLUSIVE)

SINGULAR_HESSIAN
    -> may_indicate(DEGENERATE_SECOND_ORDER_BEHAVIOUR)

HIGHER_ORDER_ANALYSIS
    -> may_be_required

# ---------- EIGENVALUE INTERPRETATION ----------
for symmetric Hessian:

all_eigenvalues > 0
    -> POSITIVE_DEFINITE

all_eigenvalues < 0
    -> NEGATIVE_DEFINITE

eigenvalues_of_both_signs
    -> INDEFINITE

EIGENVALUES
    -> represent(PRINCIPAL_SECOND_ORDER_CURVATURE_RATES)
       in(local_quadratic_context)

# ---------- TWO-VARIABLE DETERMINANT TEST ----------
for
    H = [
        [f_xx, f_xy],
        [f_yx, f_yy]
    ]

D
    := f_xx*f_yy - (f_xy)^2
       when(f_xy=f_yx)

at critical point:

if
    D > 0
    AND f_xx > 0
then
    -> LOCAL_MINIMUM

if
    D > 0
    AND f_xx < 0
then
    -> LOCAL_MAXIMUM

if
    D < 0
then
    -> SADDLE_POINT

if
    D = 0
then
    -> TEST_INCONCLUSIVE

# ---------- CONVEXITY ----------
if
    HESSIAN(f)(x)
        -> POSITIVE_SEMIDEFINITE
       for_all(x in convex_domain)
then

f
    -> CONVEX
       under(appropriate_twice_differentiable_conditions)

if
    HESSIAN(f)(x)
        -> POSITIVE_DEFINITE
       under(stronger_conditions)
then

f
    -> locally_strictly_convex

HESSIAN
    -> supports(CONVEXITY_ANALYSIS)

# ---------- NEWTON METHOD ----------
NEWTON_STEP
    := -HESSIAN(f)^(-1) * GRADIENT(f)

NEWTON_METHOD
    -> uses(GRADIENT)
    -> uses(HESSIAN)

HESSIAN_INVERTIBILITY
    -> required_for(STANDARD_NEWTON_STEP)

# ---------- OPTIMISATION ----------
HESSIAN
    -> applied_to(SECOND_ORDER_OPTIMISATION)
    -> applied_to(CRITICAL_POINT_CLASSIFICATION)
    -> applied_to(CONVEXITY_ANALYSIS)
    -> applied_to(NEWTON_METHODS)
    -> applied_to(SENSITIVITY_ANALYSIS)

# ---------- MACHINE LEARNING ----------
HESSIAN
    -> represents(SECOND_ORDER_LOSS_LANDSCAPE_INFORMATION)

HESSIAN_EIGENVALUES
    -> inform(LOCAL_CURVATURE_OF_OBJECTIVE)

SECOND_ORDER_METHODS
    -> may_use(HESSIAN_OR_APPROXIMATION)

# ---------- RELATION GRAPH ----------
SECOND_PARTIAL_DERIVATIVES
    -> populate(HESSIAN)

GRADIENT
    -> differentiated_to(HESSIAN)

HESSIAN
    -> defines(LOCAL_QUADRATIC_FORM)

HESSIAN
    -> supports(CRITICAL_POINT_CLASSIFICATION)

HESSIAN
    -> supports(CONVEXITY_ANALYSIS)

HESSIAN_EIGENVALUES
    -> determine(DEFINITENESS)
       for(SYMMETRIC_HESSIAN)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "Hessian" ~= "matrix of second-order partial derivatives of a scalar-valued function",
    "Hessian matrix" ~= "coordinate matrix encoding second-order derivative information",
    "second derivative matrix" ~= "Hessian in multivariable scalar-function context",
    "positive definite Hessian" ~= "Hessian with strictly positive quadratic form for every nonzero direction",
    "negative definite Hessian" ~= "Hessian with strictly negative quadratic form for every nonzero direction",
    "indefinite Hessian" ~= "Hessian whose quadratic form takes both positive and negative values"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    hessian_applies_to_scalar_valued_function: true,
    hessian_is_square_n_by_n: true,
    symmetry_requires_appropriate_mixed_partial_regularity: true,
    gradient_zero_is_required_for_standard_interior_extremum_test: true,
    semidefinite_hessian_can_make_second_derivative_test_inconclusive: true,
    newton_step_requires_invertible_hessian_or_modified_method: true,
    definiteness_interpretation_assumes_real_symmetric_context: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    matrix_definition: 0.99,
    gradient_relation: 0.99,
    symmetry_relation: 0.99,
    taylor_relation: 0.99,
    critical_point_classification: 0.99,
    convexity_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(scalar_function)
    -> determine(input_dimension)
    -> derive(first_partial_derivatives)
    -> derive(second_partial_derivatives)
    -> assemble(hessian_matrix)
    -> evaluate(at_requested_point_if_given)
    -> test(symmetry_conditions)
    -> identify(critical_point_context)
    -> determine(definiteness)
    -> classify(second_order_local_behaviour)
    -> analyse(convexity_or_newton_relation_if_required)
    -> validate(regularity_conditions)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed Hessian semantic graph",
    primary_entity: HESSIAN,
    preserve: [
        input_dimension,
        second_partial_entries,
        derivative_order,
        mixed_partial_order,
        symmetry_conditions,
        definiteness,
        critical_point_context
    ],
    infer_through: [
        gradients,
        second_partials,
        taylor_expansions,
        eigenvalues,
        quadratic_forms,
        optimisation,
        convexity
    ],
    avoid: [
        confusing_hessian_with_jacobian,
        assuming_symmetry_without_regularity,
        classifying_extremum_without_critical_point_context,
        treating_semidefinite_case_as_conclusive,
        inverting_singular_hessian,
        using_scalar_second_derivative_rules_without_multivariable_structure
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + HESSIAN
    + HESSIAN_MATRIX
    + GRADIENT
    + QUADRATIC_FORM
    + POSITIVE_DEFINITE
    + NEGATIVE_DEFINITE
    + NEWTON_STEP
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> HESSIAN
    -> FUNCTION_IDENTIFICATION
    -> DIMENSION_ANALYSIS
    -> FIRST_PARTIAL_ANALYSIS
    -> SECOND_PARTIAL_ANALYSIS
    -> HESSIAN_CONSTRUCTION
    -> SYMMETRY_ANALYSIS
    -> CRITICAL_POINT_ANALYSIS
    -> DEFINITENESS_ANALYSIS
    -> SECOND_ORDER_CLASSIFICATION
    -> CONVEXITY_ANALYSIS
    -> OPTIMISATION_RELATION_ANALYSIS
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW