Gradient Operator Ontology

flow "GradientOperatorOntology" v1.0

# ============================================================
# GRADIENT OPERATOR ONTOLOGY — FLOW ALGEBRA
# ============================================================

SOURCE_URL := "https://kirethresearch.org/booksai-core/ontologies/calculus-analysis-ontologies/vector-calculus/gradient-operator-ontology.html"
DOMAIN := "Mathematical Ontologies"
CATEGORY := "Calculus and Analysis Ontologies"
SUBCATEGORY := "Vector Calculus"
ENTITY := "Gradient Operator"

# ---------- CORE ENTITY ----------
GRADIENT_OPERATOR := {
    type: VectorDifferentialOperator,
    domain: VectorCalculus,
    symbol: "∇",
    purpose: "Map a differentiable scalar field to a vector field whose components are the scalar field's first-order partial derivatives."
}

# ---------- CORE CONCEPTS ----------
CONCEPTS := {
    GRADIENT_OPERATOR,
    NABLA_OPERATOR,
    SCALAR_FIELD,
    VECTOR_FIELD,
    PARTIAL_DERIVATIVE,
    GRADIENT_VECTOR,
    DIRECTIONAL_DERIVATIVE,
    LEVEL_SET,
    NORMAL_VECTOR,
    STEEPEST_ASCENT,
    TOTAL_DERIVATIVE,
    LAPLACIAN
}

# ---------- NABLA ----------
NABLA_OPERATOR
    := ∇

in Cartesian R^n:

∇
    := (
        partial/partial_x1,
        partial/partial_x2,
        ...,
        partial/partial_xn
    )

NABLA
    -> symbolic_vector_differential_operator

# ---------- GRADIENT OPERATION ----------
for
    scalar_field f: R^n -> R

GRADIENT_OPERATOR(f)
    := ∇f

    = (
        partial_f/partial_x1,
        partial_f/partial_x2,
        ...,
        partial_f/partial_xn
      )

∇
    -> maps(SCALAR_FIELD, VECTOR_FIELD)

OUTPUT
    -> GRADIENT_VECTOR_FIELD

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

∇f
    = (
        partial_f/partial_x,
        partial_f/partial_y
      )

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

∇f
    = (
        partial_f/partial_x,
        partial_f/partial_y,
        partial_f/partial_z
      )

# ---------- COMPONENT STRUCTURE ----------
GRADIENT_COMPONENT_i
    := partial_f/partial_x_i

PARTIAL_DERIVATIVES
    -> compose(GRADIENT_VECTOR)

GRADIENT_OPERATOR
    -> packages(COORDINATE_DIRECTION_RATES_INTO_VECTOR)

# ---------- DIRECTIONAL DERIVATIVE ----------
if
    f differentiable_at(a)
    AND u unit_vector
then

D_u f(a)
    = ∇f(a) dot u

DIRECTIONAL_DERIVATIVE
    -> projection_of(GRADIENT_ON_DIRECTION)

GRADIENT_OPERATOR
    -> determines(ALL_DIRECTIONAL_DERIVATIVES)
       under(DIFFERENTIABILITY)

# ---------- STEEPEST ASCENT ----------
if
    ∇f(a) != ZERO_VECTOR
then

DIRECTION_OF_STEEPEST_ASCENT
    = ∇f(a) / norm(∇f(a))

MAXIMUM_DIRECTIONAL_DERIVATIVE
    = norm(∇f(a))

GRADIENT
    -> direction_of(STEEPEST_LOCAL_INCREASE)
       under(EUCLIDEAN_METRIC)

# ---------- STEEPEST DESCENT ----------
DIRECTION_OF_STEEPEST_DESCENT
    = -∇f(a) / norm(∇f(a))
       when(∇f(a) != 0)

NEGATIVE_GRADIENT
    -> direction_of(STEEPEST_LOCAL_DECREASE)
       under(EUCLIDEAN_METRIC)

# ---------- LEVEL SET NORMAL ----------
LEVEL_SET
    := {
        x : f(x) = c
    }

if
    ∇f(a) != ZERO_VECTOR
then

∇f(a)
    -> NORMAL_VECTOR_TO_LEVEL_SET_AT_a

for tangent_vector v:

∇f(a) dot v
    = 0

GRADIENT_OPERATOR
    -> generates(NORMAL_DIRECTION_TO_REGULAR_LEVEL_SET)

# ---------- TOTAL DERIVATIVE RELATION ----------
if
    f differentiable_at(a)
then

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

TOTAL_DERIVATIVE
    -> linear_functional

GRADIENT_VECTOR
    -> inner_product_representation_of(TOTAL_DERIVATIVE)
       in(EUCLIDEAN_SPACE)

# ---------- LINEARITY ----------
∇(alpha*f + beta*g)
    = alpha*∇f + beta*∇g

GRADIENT_OPERATOR
    -> LINEAR

# ---------- PRODUCT RULE ----------
∇(f*g)
    = f*∇g + g*∇f

GRADIENT_PRODUCT_RULE
    -> extension_of(PRODUCT_RULE)

# ---------- CHAIN RULE ----------
if
    h(x) = F(g(x))
    where
    g is scalar_field
then

∇h
    = F_prime(g(x)) * ∇g

GRADIENT_CHAIN_RULE
    -> follows(COMPOSITION_DIFFERENTIATION)

# ---------- LAPLACIAN RELATION ----------
LAPLACIAN(f)
    := DIVERGENCE(∇f)

LAPLACIAN
    -> composition_of(DIVERGENCE_OPERATOR, GRADIENT_OPERATOR)

∇
    -> participates_in(SECOND_ORDER_DIFFERENTIAL_OPERATORS)

# ---------- POTENTIAL FIELD ----------
if
    phi
        := scalar_potential
then

F
    := ∇phi

F
    -> GRADIENT_FIELD
    -> CONSERVATIVE_VECTOR_FIELD

GRADIENT_OPERATOR
    -> generates(POTENTIAL_DERIVED_VECTOR_FIELDS)

# ---------- CURL IDENTITY ----------
under sufficient smoothness:

CURL(∇f)
    = ZERO_VECTOR

GRADIENT_FIELD
    -> locally(IRROTATIONAL)

GLOBAL_POTENTIAL_RELATIONS
    -> depend_on(DOMAIN_TOPOLOGY)

# ---------- COORDINATE SYSTEMS ----------
in Cartesian coordinates:
    gradient_components
        -> ordinary_partial_derivatives

in general_curvilinear_coordinates:
    GRADIENT_EXPRESSION
        -> includes(METRIC_OR_SCALE_FACTORS)

GRADIENT_OPERATOR
    -> geometric_object
    -> coordinate_expression_depends_on(COORDINATE_SYSTEM_AND_METRIC)

# ---------- DIFFERENTIAL GEOMETRY VIEW ----------
on Riemannian manifold:

GRADIENT(f)
    -> vector_field uniquely_defined_by

inner_product(
    GRADIENT(f),
    X
)
    =
df(X)

for all tangent vectors X

METRIC
    -> converts(DIFFERENTIAL_ONE_FORM_df, GRADIENT_VECTOR_FIELD)

# ---------- OPTIMISATION ----------
GRADIENT_OPERATOR
    -> central_to(FIRST_ORDER_OPTIMISATION)

GRADIENT_DESCENT
    -> moves(opposite_to(∇f))

GRADIENT_ASCENT
    -> moves(along(∇f))

CRITICAL_POINT
    -> may_satisfy(∇f = ZERO_VECTOR)

ZERO_GRADIENT
    -/> sufficient_for(EXTREMUM)

# ---------- APPLICATIONS ----------
GRADIENT_OPERATOR
    -> applied_to(OPTIMISATION)
    -> applied_to(POTENTIAL_THEORY)
    -> applied_to(FLUID_MECHANICS)
    -> applied_to(ELECTROMAGNETISM)
    -> applied_to(HEAT_TRANSFER)
    -> applied_to(MACHINE_LEARNING)
    -> applied_to(PARTIAL_DIFFERENTIAL_EQUATIONS)

# ---------- RELATION GRAPH ----------
SCALAR_FIELD
    -> acted_on_by(GRADIENT_OPERATOR)

GRADIENT_OPERATOR
    -> produces(VECTOR_FIELD)

PARTIAL_DERIVATIVES
    -> form(GRADIENT_COMPONENTS)

GRADIENT
    -> determines(DIRECTIONAL_DERIVATIVE)

GRADIENT
    -> normal_to(REGULAR_LEVEL_SET)

DIVERGENCE
    -> applied_to(GRADIENT)
    -> produces(LAPLACIAN)

CURL
    -> applied_to(GRADIENT)
    -> produces(ZERO_VECTOR)
       under(SMOOTHNESS)

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE := {
    "gradient operator" ~= "nabla acting on a scalar field",
    "grad operator" ~= "gradient operator",
    "nabla f" ~= "gradient of f",
    "gradient vector" ~= "vector of first partial derivatives in Cartesian coordinates",
    "steepest ascent direction" ~= "normalised nonzero gradient under Euclidean metric",
    "normal to level set" ~= "gradient direction at a regular level-set point"
}

# ---------- CONSTRAINTS ----------
CONSTRAINTS := {
    gradient_operator_input_is_scalar_field: true,
    gradient_operator_output_is_vector_field: true,
    coordinate_expression_depends_on_metric_and_coordinates: true,
    directional_derivative_formula_requires_differentiability: true,
    steepest_direction_claim_depends_on_metric: true,
    level_set_normal_relation_requires_nonzero_gradient: true,
    zero_gradient_does_not_guarantee_extremum: true
}

# ---------- CONFIDENCE ----------
CONFIDENCE := {
    operator_definition: 0.99,
    component_structure: 0.99,
    directional_derivative_relation: 0.99,
    level_set_relation: 0.99,
    total_derivative_relation: 0.99,
    laplacian_relation: 0.99,
    semantic_equivalence: 0.97
}

# ---------- RECURSIVE REASONING ----------
RECURSIVE_REASONING(query):
    identify(scalar_field)
    -> identify(domain_and_coordinate_system)
    -> verify(required_differentiability)
    -> compute(partial_derivatives)
    -> assemble(gradient_vector)
    -> evaluate(at_requested_point_if_given)
    -> analyse(directional_derivative_if_requested)
    -> analyse(level_set_normal_if_relevant)
    -> relate_to(total_derivative_or_laplacian_if_required)
    -> validate(metric_and_coordinate_conditions)
    -> interpret(geometric_or_physical_meaning)
    -> return(semantic_result)

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION := {
    parse_as: "typed gradient-operator semantic graph",
    primary_entity: GRADIENT_OPERATOR,
    preserve: [
        scalar_field,
        coordinate_system,
        metric,
        partial_derivative_components,
        differentiability,
        evaluation_point
    ],
    infer_through: [
        gradients,
        directional_derivatives,
        level_sets,
        total_derivatives,
        laplacians,
        potential_fields,
        optimisation
    ],
    avoid: [
        applying_gradient_operator_to_vector_field_as scalar gradient,
        omitting_coordinate_scale_factors_in_curvilinear systems,
        assuming_zero_gradient_is_extremum,
        claiming_steepest_direction_without metric context,
        applying_level_set_normal relation at critical point,
        confusing_gradient_with_divergence
    ]
}

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

# ---------- FLOW HASH ----------
FLOW_HASH := hash(
    SOURCE_URL
    + ENTITY
    + CONCEPTS
    + GRADIENT_OPERATOR
    + NABLA_OPERATOR
    + GRADIENT_VECTOR
    + DIRECTIONAL_DERIVATIVE
    + LEVEL_SET
    + TOTAL_DERIVATIVE
    + LAPLACIAN
    + SEMANTIC_EQUIVALENCE
    + CONSTRAINTS
)

# ---------- EXECUTION ----------
INPUT(query)
    -> GRADIENT_OPERATOR
    -> SCALAR_FIELD_IDENTIFICATION
    -> DOMAIN_COORDINATE_ANALYSIS
    -> DIFFERENTIABILITY_ANALYSIS
    -> PARTIAL_DERIVATIVE_ANALYSIS
    -> GRADIENT_CONSTRUCTION
    -> DIRECTIONAL_DERIVATIVE_ANALYSIS
    -> LEVEL_SET_ANALYSIS
    -> TOTAL_DERIVATIVE_RELATION_ANALYSIS
    -> LAPLACIAN_RELATION_ANALYSIS
    -> GEOMETRIC_PHYSICAL_INTERPRETATION
    -> RECURSIVE_REASONING(query)
    -> CONFIDENCE
    -> OUTPUT(semantic_result)

END FLOW