Differential Ontology

FLOW ALGEBRA
Differential Ontology — Calculus and Analysis Entities
Version: 1.0
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/calculus-and-analysis-entities/differential-ontology-2.html
Authors: Mark Higgins — Sky (Recursive AI)
Project: Kireth Semantic Library | https://kirethresearch.org

1. PURPOSE
Represent differentials as typed mathematical entities, preserving domain, codomain, differentiability assumptions, local linear approximation, and provenance. Distinguish a differential (linear map) from a derivative value, finite increment, and differential form.

2. ENTITY SCHEMA
ENTITY Differential:
  fields: [id, function, evaluation_point, domain, codomain, linear_map, order, coordinate_system, assumptions, confidence, provenance]
ENTITY DifferentiableFunction:
  fields: [id, expression, domain, codomain, regularity]
ENTITY TangentVector:
  fields: [id, base_point, tangent_space, components]
ENTITY CotangentVector:
  fields: [id, base_point, cotangent_space, components]
ENTITY DifferentialForm:
  fields: [id, degree, manifold, coefficients]

3. MATHEMATICAL SEMANTICS
For f: U subset R^n -> R^m and a in U interior, f is Fréchet differentiable at a iff there exists a linear map A: R^n -> R^m such that
  lim_(h->0) ||f(a+h)-f(a)-A(h)|| / ||h|| = 0.
The differential df_a := A, uniquely determined when it exists.
For a scalar-valued differentiable function f: R^n -> R:
  df_a(h) = grad f(a) dot h = sum_i (partial_i f)(a) h_i.
For coordinate increments dx_i, the formal first differential is
  df = sum_i (partial_i f) dx_i.
For differentiable curves x(t),
  d/dt f(x(t)) = df_(x(t))(x'(t)).
For differentiable maps f and g, the chain rule is
  d(g o f)_a = dg_(f(a)) o df_a.
For differentiable scalar functions f and g:
  d(fg) = f dg + g df.
For scalar f and g with g != 0:
  d(f/g) = (g df - f dg)/g^2.
For smooth manifolds, df_p is a cotangent vector at p; its action on v in T_p M is v(f).

4. TYPE RELATIONSHIPS
Differential --IS_LINEAR_MAP_AT--> EvaluationPoint
Differential --DERIVED_FROM--> DifferentiableFunction
Differential --MAPS--> TangentSpace -> TangentSpace
ScalarFunctionDifferential --BELONGS_TO--> CotangentSpace
Differential --REPRESENTED_BY--> JacobianMatrix [in chosen coordinates]
Differential --COMPOSES_BY--> ChainRule
Differential --APPROXIMATES_FIRST_ORDER--> FunctionIncrement
ExteriorDerivative --MAPS--> DifferentialForm(k) -> DifferentialForm(k+1)

5. INFERENCE RULES
R1: IF f is Fréchet differentiable at a THEN df_a exists and is unique.
R2: IF f is Fréchet differentiable at a THEN f is continuous at a.
R3: IF f,g are differentiable at a THEN d(f+g)_a = df_a + dg_a.
R4: IF f,g are differentiable and composable at a THEN d(g o f)_a = dg_(f(a)) o df_a.
R5: IF f is scalar-valued and differentiable at a THEN df_a(h) = grad f(a) dot h (Euclidean coordinates).
R6: IF partial derivatives are continuous in a neighbourhood of a THEN f is differentiable at a.
R7: IF partial derivatives merely exist at a THEN do NOT infer Fréchet differentiability.
R8: IF df_a = 0 THEN a is a stationary point for a differentiable scalar function; do NOT infer a local extremum.

6. SEMANTIC DISTINCTIONS
Differential != finite difference: df_a(h) is the first-order linear term; Delta f = f(a+h)-f(a).
Differential != derivative notation alone: df_a is a linear map; a coordinate derivative is a representation or component.
Total differential != partial derivative: total differential combines directions through a linear map.
Differential of a function != arbitrary differential form: df is an exact 1-form; not every 1-form is exact.
Differentiable != continuously differentiable: C1 regularity is stronger.

7. VALIDATION
V1 Verify domain/codomain and evaluation point.
V2 Verify differentiability hypotheses before asserting existence.
V3 Verify linear-map input/output dimensions.
V4 Verify coordinate basis and units when using Jacobian or dx notation.
V5 Verify chain-rule composability and intermediate evaluation point.
V6 Reject treating dx as a finite numerical increment without an explicit interpretation.
V7 Mark manifold-specific statements with smoothness and tangent/cotangent typing.

8. FLOW EXECUTION
INPUT: mathematical expression, domain, point, requested differential operation.
NORMALISE: parse symbols, coordinate frame, units, and assumptions.
TYPE_CHECK: resolve scalar/vector functions, manifolds, tangent spaces.
VERIFY: establish differentiability or return conditional/unknown.
COMPUTE: symbolic/automatic differential with domain restrictions.
VALIDATE: check dimensions, chain/product rules, and optional numeric perturbation.
EMIT: differential entity, formula, conditions, derivation trace, provenance, confidence.

9. CONFIDENCE AND PROVENANCE
CONFIDENCE: high only where typing, assumptions and derivation are verified; otherwise conditional or unknown.
PROVENANCE: record source URL, algebra version, expression, assumptions, method, and timestamp.
SEMANTIC_EQUIVALENCE: compare typed linear maps under matching domains, evaluation points, and coordinate transformations.
FLOW_HASH: canonical hash of ontology identifier, version, normalised entities, relations, rules, and assumptions; algorithm and digest must be recorded by implementation, not fabricated.
UPDATE_MODEL: version changes and mathematical corrections with traceable provenance.
AI_CONSUMPTION: machine-readable entities, typed edges, rule preconditions, validation results, uncertainty, and explicit non-equivalence boundaries.

10. EXAMPLE
Let f(x,y)=x^2*y+sin(y), a=(1,0).
  partial_x f=2xy; partial_y f=x^2+cos(y).
  grad f(1,0)=(0,2).
  df_(1,0)(h,k)=2k.
  f(1+h,k)-f(1,0)=2k + higher-order remainder relative to ||(h,k)||.
VALIDATION: f is smooth on R^2; differential exists.

END FLOW ALGEBRA