Numerical Method Ontology

FLOW ALGEBRA
NUMERICAL METHOD ONTOLOGY
Kireth Semantic Library | Computational Mathematical Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/mathematical-entities/computational-mathematical-entities/numerical-method-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)
Status: Proposed formalisation; source page text not independently verified.
Version: 1.0 | Date: 2026-10-14

1. ENTITY MODEL
entity NumericalMethod {
  problem: ComputationalProblem
  domain: MathematicalDomain
  inputs: InputSpecification
  algorithm: Ordered[ComputationalStep]
  output: ApproximateSolution | CertifiedSolution
  assumptions: Set[Precondition]
  precision: NumericPrecision
  stopping_rule: StoppingCriterion
  error_model: ErrorModel
  provenance: ProvenanceRecord
}

subtypes = {RootFindingMethod, NumericalIntegrationMethod, NumericalDifferentiationMethod,
 LinearSystemSolver, OptimisationMethod, ODESolver, PDESolver, InterpolationMethod,
 EigenvalueMethod, MonteCarloMethod}

2. TYPED RELATIONSHIPS
SOLVES: NumericalMethod -> ComputationalProblem
ACCEPTS: NumericalMethod -> InputSpecification
GENERATES: NumericalMethod -> ApproximateSolution
USES: NumericalMethod -> ComputationalAlgorithm
REQUIRES: NumericalMethod -> Precondition
ESTIMATES: NumericalMethod -> NumericalError
TERMINATES_WHEN: NumericalMethod -> StoppingCriterion
VALIDATED_BY: NumericalMethod -> ValidationProcedure
COMPARED_WITH: NumericalMethod -> ReferenceSolution

3. MATHEMATICAL FOUNDATIONS
For a mathematical problem F(x)=0, numerical iteration may be represented as
  x_(k+1) = T(x_k; parameters).
A numerical approximation x_hat has residual r = F(x_hat).
Forward error: ||x_hat - x_star||, where x_star is an exact solution.
Backward error: smallest perturbation of input data for which x_hat is exact.
Residual magnitude alone does not guarantee a small forward error without
appropriate conditioning and stability assumptions.

Absolute error = |x_hat - x_star|.
Relative error = |x_hat - x_star|/|x_star| when x_star != 0.
Convergence: lim_(k->infinity) ||x_k - x_star|| = 0.
Order p > 0 (when defined): ||e_(k+1)|| / ||e_k||^p -> C with 0 < C < infinity.

4. NUMERICAL METHOD FAMILIES
Root finding: bisection, Newton iteration, secant method.
Linear systems: Gaussian elimination, LU, conjugate gradient (under suitable assumptions).
Integration: quadrature and adaptive integration.
Differentiation: finite differences and automatic differentiation (distinguish the latter).
Differential equations: Euler, Runge-Kutta, multistep and finite element methods.
Optimisation: gradient-based and constrained numerical methods.
Stochastic computation: Monte Carlo estimation with sampling uncertainty.

5. EXECUTABLE FLOW ALGEBRA (PSEUDOSPECIFICATION)
flow NumericalMethodEvaluation v1.0 {
  input: problem, method, initial_state, parameters, tolerance, max_iterations
  require: validate_problem(problem)
  require: check_method_preconditions(method, problem, parameters)
  state := initial_state
  for k in 0..max_iterations-1 {
    next := method.step(problem, state, parameters)
    if not finite(next): return Failure("NONFINITE_ITERATE")
    residual := problem.residual(next)
    if not finite(residual): return Failure("NONFINITE_RESIDUAL")
    if method.stopping_rule(next, residual, tolerance):
      return Candidate(next, residual, k+1, "STOPPING_RULE_MET")
    state := next
  }
  return Unconverged(state, max_iterations, "ITERATION_LIMIT")
}

6. INFERENCE RULES
IF method.preconditions_hold AND method.has_proven_convergence_guarantee
AND guarantee_assumptions_hold THEN infer applicable_convergence_guarantee.
IF residual <= tolerance THEN infer residual_criterion_satisfied,
NOT automatically exact_solution OR certified_forward_accuracy.
IF successive_iterates_are_close THEN infer step_criterion_satisfied,
NOT automatically convergence_to_correct_solution.
IF output.has_rigorous_error_bound AND bound <= target_tolerance
THEN infer certified_accuracy_at_target_tolerance.
IF method.is_iterative AND stopping_rule_is_met THEN infer terminated,
NOT automatically mathematically_converged.

7. SEMANTIC DISTINCTIONS
NumericalMethod != MathematicalAlgorithm (a method specifies a numerical approach).
ApproximateSolution != ExactSolution.
NumericalError != Residual.
Convergence != Stability != Consistency.
Conditioning describes problem sensitivity; stability describes algorithmic behaviour.
Precision != Accuracy.
StoppingCriterion != ConvergenceProof.

8. VALIDATION
Check inputs, domain, units, preconditions and parameter ranges.
Check residuals, independent reference cases and known analytic benchmarks.
Record discretisation and round-off effects separately where feasible.
Use convergence studies and uncertainty estimates where appropriate.
Flag ill-conditioned cases, non-finite values and failure to converge.
Do not claim proof-level accuracy from empirical convergence alone.

9. CONFIDENCE AND SEMANTIC EQUIVALENCE
CONFIDENCE := evidence-weighted assessment of result validity; not a proof.
SEMANTIC_EQUIVALENCE(a,b) requires compatible problem, assumptions,
accuracy semantics and output interpretation; algorithm names alone do not suffice.

10. FLOW HASH AND UPDATE MODEL
FLOW_HASH := SHA256(canonical_utf8(ontology_identifier, version, entity_schema,
 relationships, rules, validation_constraints)); compute on implementation.
UPDATE_MODEL := versioned revisions with provenance, compatibility checks,
changelog, and invalidation of stale derived claims.

11. AI CONSUMPTION
Expose typed entities and relationships; preserve assumptions and units.
Report method, input, tolerance, iteration count, residual, error estimate,
termination status, confidence and provenance separately.
Never conflate a numerical approximation with a mathematically certified solution.

END FLOW ALGEBRA