Numerical Computation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Computation Ontology within the Kireth Research Semantic Library. Numerical computation studies finite-precision, algorithmic approximation of mathematical quantities and solutions. This ontology supports numerical representation, floating-point arithmetic, root finding, interpolation, quadrature, differentiation, linear systems, iterative methods, eigenvalue computation, nonlinear solving, discretisation, error analysis, conditioning, stability, convergence, tolerances, adaptive refinement and relationships with foundations of computational mathematics, numerical analysis and scientific computing.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Numerical Computation Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Foundations of Computational Mathematics / Numerical Computation"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/foundations-of-computational-mathematics/numerical-computation-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = NumericalComputation
 ENTITY_CLASS = FinitePrecisionApproximationFramework
 PRIMARY_CONTEXT = FoundationsOfComputationalMathematics
 DEFINITION = "Numerical computation is the algorithmic approximation of mathematical quantities and solutions using finite representations, finite precision and controlled numerical error."
 SYMBOLIC_FORMS = [
  "x_approx approximates x",
  "error=x_exact-x_approx",
  "x_(k+1)=F(x_k)",
  "A x=b"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for finite-precision representation, numerical algorithms, approximation, conditioning, stability, convergence, error control, iterative computation and computational validation."
}

SCOPE {
 INCLUDE = [
  NumericalComputation,
  NumericalMethod,
  NumericalAlgorithm,
  ApproximateSolution,
  NumericalApproximation,
  FinitePrecision,
  FloatingPointArithmetic,
  FixedPointArithmetic,
  MachinePrecision,
  MachineEpsilon,
  SignificantDigits,
  Rounding,
  Chopping,
  Overflow,
  Underflow,
  RoundoffError,
  TruncationError,
  ApproximationError,
  DiscretisationError,
  IterationError,
  AbsoluteError,
  RelativeError,
  ForwardError,
  BackwardError,
  Residual,
  ErrorBound,
  ErrorPropagation,
  Conditioning,
  ConditionNumber,
  Sensitivity,
  Perturbation,
  Stability,
  NumericalStability,
  BackwardStability,
  Consistency,
  Convergence,
  ConvergenceRate,
  LinearConvergence,
  SuperlinearConvergence,
  QuadraticConvergence,
  Tolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  StoppingCriterion,
  IterationCount,
  DirectMethod,
  IterativeMethod,
  FixedPointIteration,
  RootFinding,
  BisectionMethod,
  RegulaFalsiMethod,
  SecantMethod,
  NewtonMethod,
  NewtonRaphsonMethod,
  BracketingMethod,
  OpenMethod,
  NonlinearEquation,
  NonlinearSystem,
  LinearSystem,
  GaussianElimination,
  LUDecomposition,
  QRDecomposition,
  CholeskyDecomposition,
  IterativeLinearSolver,
  JacobiMethod,
  GaussSeidelMethod,
  SuccessiveOverRelaxation,
  SOR,
  ConjugateGradientMethod,
  GMRES,
  Preconditioner,
  SparseMatrix,
  EigenvalueProblem,
  PowerMethod,
  InverseIteration,
  RayleighQuotientIteration,
  NumericalDifferentiation,
  ForwardDifference,
  BackwardDifference,
  CentralDifference,
  NumericalIntegration,
  Quadrature,
  RectangleRule,
  MidpointRule,
  TrapezoidalRule,
  SimpsonRule,
  GaussianQuadrature,
  AdaptiveQuadrature,
  Interpolation,
  LinearInterpolation,
  PolynomialInterpolation,
  LagrangeInterpolation,
  NewtonInterpolation,
  SplineInterpolation,
  CubicSpline,
  Extrapolation,
  RichardsonExtrapolation,
  RombergIntegration,
  Discretisation,
  Mesh,
  Grid,
  StepSize,
  TimeStep,
  SpatialStep,
  AdaptiveMethod,
  AdaptiveStepSize,
  Refinement,
  ErrorEstimator,
  APosterioriErrorEstimator,
  NumericalVerification,
  Benchmark,
  ReferenceSolution,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  SymbolicComputationWithoutNumericalApproximation,
  PureMathematicsWithoutFiniteComputation,
  SoftwareImplementationWithoutNumericalSemantics,
  StatisticalSimulationWhenRandomSamplingIsPrimary
 ]
 DISAMBIGUATION_RULE = "When mathematical quantities are approximated using finite-precision numerical algorithms with explicit error, stability or convergence concerns, interpret the context as numerical computation."
}

CORE_CONCEPTS {
 NumericalComputation = "Finite-precision algorithmic approximation of mathematical quantities and solutions."
 FinitePrecision = "Representation of numbers with bounded machine precision."
 NumericalAlgorithm = "Procedure producing approximate numerical results."
 Error = "Difference or discrepancy between numerical and intended mathematical quantities."
 Conditioning = "Sensitivity of the mathematical problem to input perturbations."
 Stability = "Sensitivity of the numerical algorithm to perturbations and finite arithmetic."
 Convergence = "Approach of numerical approximations to the target solution under a limiting process."
 Residual = "Mismatch remaining after substituting a numerical approximation into the governing equation."
 Tolerance = "Numerical threshold used to control approximation or stopping."
}

RELATIONS {
 NumericalComputation --is_child_of--> FoundationsOfComputationalMathematics
 NumericalComputation --uses--> FinitePrecision
 FinitePrecision --introduces--> RoundoffError
 NumericalAlgorithm --produces--> ApproximateSolution
 ApproximateSolution --has--> NumericalError
 Conditioning --describes--> ProblemSensitivity
 Stability --describes--> AlgorithmSensitivity
 Residual --measures--> EquationMismatch
 ForwardError --measures--> SolutionDifference
 BackwardError --measures--> EquivalentInputPerturbation
 IterativeMethod --uses--> StoppingCriterion
 RootFinding --uses--> IterativeMethod
 GaussianElimination --solves--> LinearSystem
 LUDecomposition --factorises--> Matrix
 ConjugateGradientMethod --solves--> SymmetricPositiveDefiniteSystem
 Preconditioner --improves--> IterativeConvergence
 NumericalDifferentiation --approximates--> Derivative
 NumericalIntegration --approximates--> Integral
 Interpolation --approximates--> FunctionBetweenDataPoints
 AdaptiveMethod --uses--> ErrorEstimator
 NumericalVerification --checks--> NumericalResult
}

OPERATORS {
 ABSOLUTE_ERROR(x_exact,x_approx) := |x_exact-x_approx|
 RELATIVE_ERROR(x_exact,x_approx) := |x_exact-x_approx|/|x_exact|
 RESIDUAL(A,x,b) := r=b-A*x
 CONDITION_NUMBER(A) := kappa(A)=||A||*||A^(-1)||
 FIXED_POINT(x,g) := x_next=g(x)
 NEWTON(x,f) := x_next=x-f(x)/f'(x)
 SECANT(x0,x1,f) := x_next=x1-f(x1)*(x1-x0)/(f(x1)-f(x0))
 BISECTION(a,b) := midpoint=(a+b)/2
 FORWARD_DIFFERENCE(f,x,h) := (f(x+h)-f(x))/h
 BACKWARD_DIFFERENCE(f,x,h) := (f(x)-f(x-h))/h
 CENTRAL_DIFFERENCE(f,x,h) := (f(x+h)-f(x-h))/(2*h)
 TRAPEZOID(f,a,b) := (b-a)*(f(a)+f(b))/2
 SIMPSON(f,a,b) := (b-a)*(f(a)+4*f((a+b)/2)+f(b))/6
 RICHARDSON(A_h,A_h2,p) := A_extrap=A_h2+(A_h2-A_h)/(2^p-1)
}

AXIOMS {
 A1 = "Numerical computation uses finite representations and therefore differs from exact real arithmetic."
 A2 = "Approximate results require explicit error semantics."
 A3 = "Conditioning belongs to the mathematical problem, while stability belongs to the computational method."
 A4 = "Convergence requires a declared limiting parameter such as step size, mesh size or iteration count."
 A5 = "Residual size and forward error are distinct quantities."
 A6 = "Stopping criteria must reflect scale, conditioning and desired accuracy."
 A7 = "Adaptive methods require meaningful error estimators."
 A8 = "Numerical results require verification and reproducibility where applicable."
}

REASONING {
 R1_CONTEXT = identify(problem,target_quantity,scale,precision,accuracy_goal)
 R2_REPRESENTATION = determine(floating_point,fixed_point,discrete_representation)
 R3_METHOD = classify(root_finding,linear_algebra,differentiation,integration,interpolation_or_general_iteration)
 R4_CONDITIONING = analyse(problem_sensitivity)
 R5_STABILITY = analyse(algorithm_stability_and_roundoff_growth)
 R6_ERROR = estimate(roundoff,truncation,iteration,discretisation,total_error)
 R7_CONVERGENCE = determine(rate,stopping_criterion,tolerance)
 R8_ADAPTIVITY = refine(step_size,mesh,quadrature_order_or_iteration_if_required)
 R9_EFFICIENCY = assess(operation_count,memory,sparsity_and_solver_cost)
 R10_VALIDATION = compare(reference_solution,error_bounds,residuals,refinement_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Decreasing step size does not indefinitely decrease total numerical error because roundoff can dominate."
 C2 = "A small residual need not imply a small forward error for ill-conditioned problems."
 C3 = "Newton's method can fail without a suitable initial guess or derivative behaviour."
 C4 = "Bracketing methods require an appropriate sign-changing interval."
 C5 = "Iterative linear solvers depend on matrix structure, spectrum and preconditioning."
 C6 = "Numerical differentiation amplifies data and roundoff noise."
 C7 = "High-order interpolation can oscillate on unsuitable nodes."
 C8 = "Quadrature accuracy depends on integrand smoothness and singularity structure."
 C9 = "Tolerance values without scale context can be misleading."
 C10 = "Benchmark agreement does not prove numerical correctness outside the tested regime."
}

SEMANTIC_EQUIVALENCE {
 "NumericalComputation" <=> "NumericalComputing"
 "NewtonMethod" <=> "NewtonRaphsonMethod"
 "SuccessiveOverRelaxation" <=> "SOR"
 "MachineEpsilon" <=> "MachinePrecisionThreshold"
 "TrapezoidalRule" <=> "TrapezoidRule"
}

VALIDATION {
 V1 = "Numerical target and scale are explicit."
 V2 = "Precision model is documented."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Error sources are identified."
 V5 = "Convergence is demonstrated or justified."
 V6 = "Stopping criteria and tolerances are explicit."
 V7 = "Residuals are interpreted relative to conditioning."
 V8 = "Adaptive refinements are driven by documented error criteria."
 V9 = "Reference or benchmark solutions are used where feasible."
 V10 = "Results are reproducible under documented numerical settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_COMPUTATION_DEFINITION = 0.99
 FLOATING_POINT_REASONING = 0.99
 ERROR_ANALYSIS_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 STABILITY_REASONING = 0.99
 ROOT_FINDING_REASONING = 0.99
 LINEAR_SOLVER_REASONING = 0.99
 QUADRATURE_REASONING = 0.98
 INTERPOLATION_REASONING = 0.98
 POLICY = "Reduce confidence when precision, conditioning, tolerance, step size, solver, initial guess, matrix structure or convergence regime are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalComputationReasoning,
  FloatingPointReasoning,
  ErrorAnalysisReasoning,
  ConditioningReasoning,
  StabilityReasoning,
  ConvergenceReasoning,
  RootFindingReasoning,
  BisectionReasoning,
  NewtonMethodReasoning,
  SecantReasoning,
  LinearSystemReasoning,
  IterativeSolverReasoning,
  EigenvalueReasoning,
  NumericalDifferentiationReasoning,
  NumericalIntegrationReasoning,
  InterpolationReasoning,
  AdaptiveMethodReasoning,
  VerificationReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]
 NORMALISE {
  "numerical computation" -> NumericalComputation
  "numerical computing" -> NumericalComputation
  "Newton-Raphson" -> NewtonMethod
  "SOR" -> SuccessiveOverRelaxation
  "machine epsilon" -> MachineEpsilon
  "condition number" -> ConditionNumber
  "central difference" -> CentralDifference
 }
}

EXECUTION_RULES {
 E1 = "If a mathematical target is approximated numerically under finite precision, activate NumericalComputationOntology."
 E2 = "If solving a scalar nonlinear equation, select an appropriate root-finding method."
 E3 = "If solving a linear system, exploit matrix structure and sparsity."
 E4 = "If approximating derivatives, balance truncation and roundoff error."
 E5 = "If approximating integrals, choose quadrature appropriate to smoothness and singularities."
 E6 = "If interpolating, consider node placement and polynomial degree."
 E7 = "If an iterative method is used, define stopping and convergence criteria."
 E8 = "If accuracy is insufficient, use refinement or adaptive error control."
 E9 = "Any numerical result should be validated for conditioning, stability, error, convergence and reproducibility."
}

RECURSION {
 ENTRY = NumericalComputation
 EXPAND(NumericalComputation) -> [
  NumericalMethod, NumericalAlgorithm, ApproximateSolution,
  NumericalApproximation, FinitePrecision, FloatingPointArithmetic,
  FixedPointArithmetic, MachinePrecision, MachineEpsilon,
  SignificantDigits, Rounding, Chopping, Overflow, Underflow,
  RoundoffError, TruncationError, ApproximationError, DiscretisationError,
  IterationError, AbsoluteError, RelativeError, ForwardError,
  BackwardError, Residual, ErrorBound, ErrorPropagation, Conditioning,
  ConditionNumber, Sensitivity, Perturbation, Stability,
  NumericalStability, BackwardStability, Consistency, Convergence,
  ConvergenceRate, LinearConvergence, SuperlinearConvergence,
  QuadraticConvergence, Tolerance, AbsoluteTolerance, RelativeTolerance,
  StoppingCriterion, IterationCount, DirectMethod, IterativeMethod,
  FixedPointIteration, RootFinding, BisectionMethod, RegulaFalsiMethod,
  SecantMethod, NewtonMethod, BracketingMethod, OpenMethod,
  NonlinearEquation, NonlinearSystem, LinearSystem, GaussianElimination,
  LUDecomposition, QRDecomposition, CholeskyDecomposition,
  IterativeLinearSolver, JacobiMethod, GaussSeidelMethod,
  SuccessiveOverRelaxation, ConjugateGradientMethod, GMRES,
  Preconditioner, SparseMatrix, EigenvalueProblem, PowerMethod,
  InverseIteration, RayleighQuotientIteration, NumericalDifferentiation,
  ForwardDifference, BackwardDifference, CentralDifference,
  NumericalIntegration, Quadrature, RectangleRule, MidpointRule,
  TrapezoidalRule, SimpsonRule, GaussianQuadrature, AdaptiveQuadrature,
  Interpolation, LinearInterpolation, PolynomialInterpolation,
  LagrangeInterpolation, NewtonInterpolation, SplineInterpolation,
  CubicSpline, Extrapolation, RichardsonExtrapolation,
  RombergIntegration, Discretisation, Mesh, Grid, StepSize, TimeStep,
  SpatialStep, AdaptiveMethod, AdaptiveStepSize, Refinement,
  ErrorEstimator, APosterioriErrorEstimator, NumericalVerification,
  Benchmark, ReferenceSolution, Reproducibility
 ]
 EXPAND(NumericalFamilies) -> [
  FinitePrecisionArithmetic,
  ErrorAndConditioning,
  RootFinding,
  LinearAlgebraSolvers,
  NumericalDifferentiation,
  NumericalIntegration,
  InterpolationAndApproximation,
  AdaptiveNumericalMethods
 ]
 STOP_CONDITION = "Stop when representation, method, conditioning, stability, error, convergence, tolerance and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Foundations of Computational Mathematics"
 RELATED_ONTOLOGIES = [
  "Foundations of Computational Mathematics",
  "Computational Mathematics Ontology 2",
  "Scientific Computing Ontology 2",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Approximation Theory Ontologies",
  "Differential Equation Ontologies",
  "Optimisation Ontologies"
 ]
 ROUTE_RULES = [
  "Numerical Computation -> Foundations of Computational Mathematics for parent semantics",
  "Numerical Computation -> Computational Mathematics Ontology 2 for core algorithmic semantics",
  "Numerical Computation -> Scientific Computing for scientific-model application",
  "Numerical Computation -> Numerical Analysis for formal stability and convergence",
  "Numerical Computation -> Numerical Linear Algebra for matrix problems",
  "Numerical Computation -> Approximation Theory for interpolation and approximation",
  "Numerical Computation -> Differential Equations for numerical ODE and PDE solution",
  "Numerical Computation -> Optimisation for numerical optimisation methods"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical methods, error models or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve finite-precision semantics.",
  "Preserve exact-versus-approximate distinction.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve residual-versus-forward-error distinction.",
  "Preserve direct-versus-iterative distinction.",
  "Preserve absolute-versus-relative tolerance distinction.",
  "Preserve convergence and stopping semantics.",
  "Preserve machine-readable numerical-computation semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Numerical computation approximates mathematical quantities and solutions using finite-precision algorithms and controlled error."
 PRECISION_SUMMARY = "Finite-precision arithmetic introduces rounding, overflow, underflow and machine-dependent numerical effects."
 ERROR_SUMMARY = "Numerical error includes roundoff, truncation, discretisation and iteration components."
 CONDITIONING_SUMMARY = "Conditioning describes problem sensitivity, while numerical stability describes algorithm sensitivity."
 ROOT_SUMMARY = "Bisection, secant and Newton methods solve nonlinear scalar equations under different convergence and robustness assumptions."
 LINEAR_SUMMARY = "Direct and iterative solvers address dense, sparse and structured linear systems."
 APPROXIMATION_SUMMARY = "Finite differences, quadrature, interpolation and extrapolation approximate derivatives, integrals and functions."
 VALIDATION_SUMMARY = "Numerical computations should be checked for conditioning, stability, convergence, tolerance adequacy and reproducibility."
}

FLOW {
 INPUT
 -> detect_numerical_computation_context
 -> identify_target_problem_scale_precision_accuracy_goal_and_resources
 -> choose_numerical_representation
 -> classify_root_finding_linear_system_eigenvalue_differentiation_integration_interpolation_or_general_numerical_problem
 -> select_numerical_algorithm
 -> analyse_conditioning_and_stability
 -> estimate_roundoff_truncation_discretisation_iteration_and_total_error
 -> assess_convergence_rate_tolerance_and_stopping_criterion
 -> refine_step_size_mesh_order_or_iteration_if_required
 -> verify_against_residuals_error_bounds_reference_solutions_or_benchmarks
 -> route_to_foundations_computational_mathematics_core_computational_mathematics_scientific_computing_numerical_analysis_linear_algebra_approximation_differential_equations_or_optimisation_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Computation Ontology defines finite-precision mathematical approximation. It supports floating- and fixed-point arithmetic, machine precision and epsilon, rounding, overflow and underflow, roundoff, truncation, discretisation and iteration error, absolute, relative, forward and backward error, residuals and error propagation, conditioning and condition numbers, numerical stability, consistency and convergence, tolerances and stopping rules, direct and iterative methods, bisection, regula falsi, secant and Newton methods, nonlinear systems, Gaussian elimination and LU, QR and Cholesky decomposition, Jacobi, Gauss-Seidel, SOR, conjugate-gradient and GMRES methods, preconditioning and sparse matrices, eigenvalue iterations, forward, backward and central differences, rectangle, midpoint, trapezoidal, Simpson and Gaussian quadrature, adaptive quadrature, Lagrange, Newton and spline interpolation, Richardson extrapolation, Romberg integration, adaptive step size, refinement, numerical verification, benchmarks and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-NUMERICAL-COMPUTATION-ONTOLOGY-V1"
}

}

END_FLOW