Numerical Methods

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Methods layer within the Kireth Research Semantic Library. Numerical methods are computational procedures used to approximate solutions to mathematical problems that may be difficult or impossible to solve exactly. This parent ontology connects numerical linear algebra, root finding, interpolation, approximation, numerical differentiation and integration, numerical ordinary and partial differential equations, optimisation, iterative methods, error analysis, stability, convergence, adaptive methods and scientific computing.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalMethods
 ENTITY_CLASS = NumericalApproximationFramework
 PRIMARY_CONTEXT = ComputationalMathematicsOntologies
 DEFINITION = "Numerical methods are algorithmic techniques for approximating mathematical quantities, solving equations and simulating mathematical models using finite computation."
 SYMBOLIC_FORMS = [
  "x_(k+1)=F(x_k)",
  "A x=b",
  "I approximately Q_h(f)",
  "u_h approximates u"
 ]
 SEMANTIC_ROLE = "Provides the parent semantic framework for numerical approximation, iterative solving, discretisation, error analysis, numerical linear algebra, differential equations, quadrature, interpolation, optimisation and computational verification."
}

SCOPE {
 INCLUDE = [
  NumericalMethods,
  NumericalMethod,
  NumericalAlgorithm,
  ApproximateSolution,
  NumericalApproximation,
  DirectMethod,
  IterativeMethod,
  RootFinding,
  FixedPointIteration,
  BisectionMethod,
  SecantMethod,
  NewtonMethod,
  NewtonRaphsonMethod,
  RegulaFalsiMethod,
  NonlinearEquation,
  NonlinearSystem,
  LinearSystem,
  NumericalLinearAlgebra,
  GaussianElimination,
  LUDecomposition,
  QRDecomposition,
  CholeskyDecomposition,
  IterativeLinearSolver,
  JacobiMethod,
  GaussSeidelMethod,
  SuccessiveOverRelaxation,
  ConjugateGradientMethod,
  GMRES,
  KrylovMethod,
  Preconditioner,
  SparseMatrix,
  MatrixDecomposition,
  EigenvalueProblem,
  PowerMethod,
  InverseIteration,
  RayleighQuotientIteration,
  NumericalDifferentiation,
  ForwardDifference,
  BackwardDifference,
  CentralDifference,
  FiniteDifferenceMethod,
  NumericalIntegration,
  Quadrature,
  RectangleRule,
  MidpointRule,
  TrapezoidalRule,
  SimpsonRule,
  GaussianQuadrature,
  AdaptiveQuadrature,
  MonteCarloIntegration,
  Interpolation,
  LinearInterpolation,
  PolynomialInterpolation,
  LagrangeInterpolation,
  NewtonInterpolation,
  SplineInterpolation,
  CubicSpline,
  Extrapolation,
  RichardsonExtrapolation,
  RombergIntegration,
  ApproximationTheory,
  PolynomialApproximation,
  LeastSquaresApproximation,
  SpectralApproximation,
  NumericalODE,
  InitialValueProblem,
  BoundaryValueProblem,
  EulerMethod,
  ImprovedEulerMethod,
  RungeKuttaMethod,
  RungeKuttaFourthOrder,
  MultistepMethod,
  AdamsBashforthMethod,
  AdamsMoultonMethod,
  BackwardDifferentiationFormula,
  PredictorCorrectorMethod,
  StiffEquation,
  NumericalPDE,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod,
  BoundaryElementMethod,
  MethodOfLines,
  EllipticPDE,
  ParabolicPDE,
  HyperbolicPDE,
  ComputationalOptimisation,
  GradientDescent,
  NewtonOptimisation,
  QuasiNewtonMethod,
  TrustRegionMethod,
  LineSearch,
  ConstrainedOptimisation,
  UnconstrainedOptimisation,
  Discretisation,
  Mesh,
  Grid,
  StepSize,
  TimeStep,
  SpatialStep,
  AdaptiveMethod,
  AdaptiveStepSize,
  AdaptiveMesh,
  ErrorEstimator,
  APosterioriErrorEstimator,
  FloatingPointArithmetic,
  MachinePrecision,
  RoundoffError,
  TruncationError,
  DiscretisationError,
  IterationError,
  AbsoluteError,
  RelativeError,
  ForwardError,
  BackwardError,
  Residual,
  Conditioning,
  ConditionNumber,
  Stability,
  NumericalStability,
  Consistency,
  Convergence,
  ConvergenceRate,
  Tolerance,
  StoppingCriterion,
  Verification,
  Validation,
  Benchmarking,
  ReferenceSolution,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  SymbolicComputationWithoutNumericalApproximation,
  PureAnalyticalSolutionWithoutNumericalMethod,
  SoftwareEngineeringWithoutMathematicalNumerics,
  ExperimentalMeasurementWithoutNumericalModel
 ]
 DISAMBIGUATION_RULE = "When a mathematical quantity or solution is approximated using finite numerical procedures, interpret the context as numerical methods."
}

CORE_CONCEPTS {
 NumericalMethods = "Family of computational procedures for approximating mathematical solutions."
 NumericalAlgorithm = "Finite computational procedure producing a numerical result."
 ApproximateSolution = "Numerical estimate of an exact mathematical solution."
 IterativeMethod = "Method that improves an approximation through repeated updates."
 DirectMethod = "Method intended to obtain a solution in a finite sequence of algebraic operations subject to arithmetic precision."
 Discretisation = "Replacement of continuous structure by a finite numerical representation."
 ErrorAnalysis = "Study of approximation and computational errors."
 Stability = "Sensitivity of a numerical method to perturbations and accumulated error."
 Convergence = "Approach of a numerical approximation to the intended solution."
}

RELATIONS {
 NumericalMethods --is_child_of--> ComputationalMathematicsOntologies
 NumericalMethod --produces--> ApproximateSolution
 IterativeMethod --uses--> Iteration
 IterativeMethod --uses--> StoppingCriterion
 RootFinding --solves--> NonlinearEquation
 GaussianElimination --solves--> LinearSystem
 LUDecomposition --factorises--> Matrix
 IterativeLinearSolver --may_use--> Preconditioner
 NumericalDifferentiation --approximates--> Derivative
 NumericalIntegration --approximates--> Integral
 Interpolation --approximates--> FunctionBetweenKnownPoints
 NumericalODE --approximates--> ODESolution
 NumericalPDE --approximates--> PDESolution
 Discretisation --produces--> FiniteComputationalProblem
 FiniteDifferenceMethod --uses--> DifferenceApproximation
 FiniteElementMethod --uses--> PiecewiseBasisFunctions
 FiniteVolumeMethod --uses--> ConservationBalance
 SpectralMethod --uses--> GlobalBasisFunctions
 ErrorEstimator --guides--> AdaptiveMethod
 Conditioning --describes--> ProblemSensitivity
 Stability --describes--> MethodSensitivity
 Consistency --supports--> Convergence
 Verification --checks--> NumericalImplementation
}

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_ROOT(x,f) := x_next=x-f(x)/f'(x)
 BISECTION_STEP(a,b) := midpoint=(a+b)/2
 FORWARD_DIFFERENCE(f,x,h) := (f(x+h)-f(x))/h
 CENTRAL_DIFFERENCE(f,x,h) := (f(x+h)-f(x-h))/(2*h)
 TRAPEZOID_RULE(f,a,b) := (b-a)*(f(a)+f(b))/2
 SIMPSON_RULE(f,a,b) := (b-a)*(f(a)+4*f((a+b)/2)+f(b))/6
 EULER_STEP(y,t,h,f) := y_next=y+h*f(t,y)
 RK4_STEP(y,t,h,f) := weighted_four_stage_Runge_Kutta_update
}

AXIOMS {
 A1 = "Numerical methods produce finite approximations rather than exact real-number computation in general."
 A2 = "Approximate numerical results require explicit error semantics."
 A3 = "Conditioning belongs to the mathematical problem, while stability belongs to the numerical method."
 A4 = "Convergence requires a declared limiting process."
 A5 = "Discretisation parameters affect accuracy, stability and computational cost."
 A6 = "Iterative methods require stopping criteria."
 A7 = "Finite precision introduces rounding and representation effects."
 A8 = "Numerical conclusions require verification, convergence and reproducibility checks."
}

REASONING {
 R1_CONTEXT = identify(problem_type,target_quantity,dimension,precision,accuracy_goal)
 R2_CLASS = classify(root,linear_system,eigenvalue,derivative,integral,interpolation,ODE,PDE_or_optimisation)
 R3_METHOD = select(direct,iterative,adaptive,spectral_or_discretisation_method)
 R4_CONDITIONING = analyse(problem_sensitivity)
 R5_STABILITY = analyse(method_stability_and_roundoff_growth)
 R6_ERROR = estimate(truncation,roundoff,discretisation,iteration_and_total_error)
 R7_CONVERGENCE = determine(rate,tolerance,stopping_criterion)
 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,residual,error_bounds,refinement_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Smaller step sizes do not always reduce total error because roundoff can eventually dominate."
 C2 = "A small residual does not necessarily imply small forward error for ill-conditioned problems."
 C3 = "Newton-type methods can fail without suitable initialisation or derivative behaviour."
 C4 = "Explicit time-stepping methods can become unstable if stability restrictions are violated."
 C5 = "Iterative linear solvers depend on matrix spectrum and preconditioning."
 C6 = "Numerical differentiation amplifies noise."
 C7 = "High-order interpolation can oscillate for unsuitable nodes."
 C8 = "Quadrature accuracy depends on integrand smoothness and singularity structure."
 C9 = "Adaptive refinement requires reliable error indicators."
 C10 = "Benchmark agreement does not prove correctness outside the tested regime."
}

SEMANTIC_EQUIVALENCE {
 "NumericalMethods" <=> "NumericalTechniques"
 "NewtonMethod" <=> "NewtonRaphsonMethod"
 "SuccessiveOverRelaxation" <=> "SOR"
 "FiniteDifferenceMethod" <=> "FDM"
 "FiniteElementMethod" <=> "FEM"
 "FiniteVolumeMethod" <=> "FVM"
}

VALIDATION {
 V1 = "Numerical problem and target quantity are explicit."
 V2 = "Precision model and numerical representation are documented."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Error sources are identified."
 V5 = "Stability is assessed."
 V6 = "Convergence is demonstrated or justified."
 V7 = "Stopping criteria and tolerances are explicit."
 V8 = "Adaptive refinement is 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_METHODS_DEFINITION = 0.99
 ROOT_FINDING_REASONING = 0.99
 LINEAR_SOLVER_REASONING = 0.99
 DIFFERENTIATION_REASONING = 0.99
 QUADRATURE_REASONING = 0.99
 ODE_REASONING = 0.99
 PDE_REASONING = 0.98
 ERROR_ANALYSIS_REASONING = 0.99
 POLICY = "Reduce confidence when numerical method, discretisation, conditioning, tolerance, step size, mesh, solver, initial guess or convergence regime are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalMethodsReasoning,
  RootFindingReasoning,
  NumericalLinearAlgebraReasoning,
  EigenvalueReasoning,
  NumericalDifferentiationReasoning,
  NumericalIntegrationReasoning,
  InterpolationReasoning,
  ApproximationReasoning,
  NumericalODEReasoning,
  NumericalPDEReasoning,
  FiniteDifferenceReasoning,
  FiniteElementReasoning,
  FiniteVolumeReasoning,
  SpectralMethodReasoning,
  NumericalOptimisationReasoning,
  ErrorAnalysisReasoning,
  StabilityReasoning,
  ConvergenceReasoning,
  AdaptiveMethodReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]
 NORMALISE {
  "numerical methods" -> NumericalMethods
  "numerical techniques" -> NumericalMethods
  "Newton-Raphson" -> NewtonMethod
  "SOR" -> SuccessiveOverRelaxation
  "FDM" -> FiniteDifferenceMethod
  "FEM" -> FiniteElementMethod
  "FVM" -> FiniteVolumeMethod
 }
}

EXECUTION_RULES {
 E1 = "If a mathematical problem is solved approximately with finite numerical computation, activate NumericalMethods."
 E2 = "If solving a nonlinear scalar equation, route to root-finding methods."
 E3 = "If solving matrix systems, route to numerical linear algebra."
 E4 = "If derivatives or integrals are approximated, route to numerical differentiation or quadrature."
 E5 = "If functions are reconstructed from data points, route to interpolation or approximation methods."
 E6 = "If ordinary differential equations are solved numerically, route to numerical ODE methods."
 E7 = "If partial differential equations are discretised, route to FDM, FEM, FVM, spectral or related methods."
 E8 = "If accuracy is insufficient, consider adaptive refinement."
 E9 = "Any numerical method should be validated for conditioning, stability, error, convergence and reproducibility."
}

RECURSION {
 ENTRY = NumericalMethods
 EXPAND(NumericalMethods) -> [
  NumericalMethod, NumericalAlgorithm, ApproximateSolution,
  NumericalApproximation, DirectMethod, IterativeMethod, RootFinding,
  FixedPointIteration, BisectionMethod, SecantMethod, NewtonMethod,
  RegulaFalsiMethod, NonlinearEquation, NonlinearSystem, LinearSystem,
  NumericalLinearAlgebra, GaussianElimination, LUDecomposition,
  QRDecomposition, CholeskyDecomposition, IterativeLinearSolver,
  JacobiMethod, GaussSeidelMethod, SuccessiveOverRelaxation,
  ConjugateGradientMethod, GMRES, KrylovMethod, Preconditioner,
  SparseMatrix, MatrixDecomposition, EigenvalueProblem, PowerMethod,
  InverseIteration, RayleighQuotientIteration, NumericalDifferentiation,
  ForwardDifference, BackwardDifference, CentralDifference,
  FiniteDifferenceMethod, NumericalIntegration, Quadrature, RectangleRule,
  MidpointRule, TrapezoidalRule, SimpsonRule, GaussianQuadrature,
  AdaptiveQuadrature, MonteCarloIntegration, Interpolation,
  LinearInterpolation, PolynomialInterpolation, LagrangeInterpolation,
  NewtonInterpolation, SplineInterpolation, CubicSpline, Extrapolation,
  RichardsonExtrapolation, RombergIntegration, ApproximationTheory,
  LeastSquaresApproximation, SpectralApproximation, NumericalODE,
  InitialValueProblem, BoundaryValueProblem, EulerMethod,
  ImprovedEulerMethod, RungeKuttaMethod, RungeKuttaFourthOrder,
  MultistepMethod, AdamsBashforthMethod, AdamsMoultonMethod,
  BackwardDifferentiationFormula, PredictorCorrectorMethod,
  StiffEquation, NumericalPDE, FiniteElementMethod, FiniteVolumeMethod,
  SpectralMethod, BoundaryElementMethod, MethodOfLines,
  ComputationalOptimisation, GradientDescent, NewtonOptimisation,
  QuasiNewtonMethod, TrustRegionMethod, LineSearch, Discretisation,
  Mesh, Grid, StepSize, TimeStep, SpatialStep, AdaptiveMethod,
  AdaptiveStepSize, AdaptiveMesh, ErrorEstimator,
  APosterioriErrorEstimator, FloatingPointArithmetic, MachinePrecision,
  RoundoffError, TruncationError, DiscretisationError, IterationError,
  AbsoluteError, RelativeError, ForwardError, BackwardError, Residual,
  Conditioning, ConditionNumber, Stability, NumericalStability,
  Consistency, Convergence, ConvergenceRate, Tolerance, StoppingCriterion,
  Verification, Validation, Benchmarking, ReferenceSolution,
  Reproducibility
 ]
 EXPAND(MethodFamilies) -> [
  RootFindingMethods,
  NumericalLinearAlgebraMethods,
  NumericalDifferentiationMethods,
  NumericalIntegrationMethods,
  InterpolationAndApproximationMethods,
  NumericalODEMethods,
  NumericalPDEMethods,
  NumericalOptimisationMethods,
  AdaptiveNumericalMethods
 ]
 STOP_CONDITION = "Stop when problem class, numerical method, representation, error, stability, convergence, tolerance and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics Ontologies"
 RELATED_ONTOLOGIES = [
  "Foundations of Computational Mathematics",
  "Numerical Computation Ontology",
  "Scientific Computing Ontology 2",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Approximation Theory Ontologies",
  "Differential Equation Ontologies",
  "Optimisation Ontologies",
  "Monte Carlo Ontologies"
 ]
 ROUTE_RULES = [
  "Numerical Methods -> Computational Mathematics Ontologies for parent semantics",
  "Numerical Methods -> Foundations of Computational Mathematics for foundational error and stability semantics",
  "Numerical Methods -> Numerical Computation for finite-precision computation",
  "Numerical Methods -> Scientific Computing for scientific-model application",
  "Numerical Methods -> Numerical Analysis for formal convergence and stability",
  "Numerical Methods -> Numerical Linear Algebra for matrix computation",
  "Numerical Methods -> Approximation Theory for interpolation and approximation",
  "Numerical Methods -> Differential Equations for numerical ODE and PDE solving",
  "Numerical Methods -> Optimisation for numerical optimisation",
  "Numerical Methods -> Monte Carlo for stochastic numerical integration"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical methods, discretisations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve exact-versus-approximate distinction.",
  "Preserve direct-versus-iterative method distinction.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve residual-versus-error distinction.",
  "Preserve fixed-versus-adaptive method distinction.",
  "Preserve ODE-versus-PDE numerical distinction.",
  "Preserve convergence semantics.",
  "Preserve machine-readable numerical-methods semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Numerical methods are finite computational techniques for approximating mathematical quantities and solutions."
 ROOT_SUMMARY = "Root-finding methods iteratively solve nonlinear equations."
 LINEAR_SUMMARY = "Direct and iterative numerical linear algebra methods solve matrix systems and eigenproblems."
 APPROXIMATION_SUMMARY = "Difference formulas, quadrature, interpolation and spectral approximations estimate derivatives, integrals and functions."
 ODE_SUMMARY = "Euler, Runge-Kutta and multistep methods approximate ordinary differential equations."
 PDE_SUMMARY = "Finite-difference, finite-element, finite-volume and spectral methods discretise partial differential equations."
 ERROR_SUMMARY = "Numerical error includes roundoff, truncation, discretisation and iteration components."
 VALIDATION_SUMMARY = "Numerical methods should be checked for conditioning, stability, convergence, error control and reproducibility."
}

FLOW {
 INPUT
 -> detect_numerical_methods_context
 -> identify_problem_class_target_quantity_dimension_precision_and_accuracy_goal
 -> select_root_finding_linear_algebra_differentiation_integration_interpolation_ODE_PDE_or_optimisation_family
 -> choose_direct_iterative_fixed_step_adaptive_or_discretised_method
 -> analyse_conditioning_and_stability
 -> estimate_roundoff_truncation_discretisation_iteration_and_total_error
 -> assess_convergence_rate_tolerance_and_stopping_criterion
 -> refine_step_size_mesh_order_preconditioner_or_iteration_if_required
 -> verify_against_residuals_error_bounds_reference_solutions_or_benchmarks
 -> route_to_computational_mathematics_foundations_numerical_computation_scientific_computing_numerical_analysis_linear_algebra_approximation_differential_equations_optimisation_or_Monte_Carlo_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Methods layer defines computational approximation techniques across mathematics. It supports direct and iterative algorithms, root finding and fixed-point methods, nonlinear equations, numerical linear algebra, Gaussian elimination, matrix decompositions, stationary and Krylov iterative solvers, preconditioning and sparse matrices, eigenvalue methods, numerical differentiation and finite differences, numerical integration, quadrature and adaptive quadrature, interpolation, splines, extrapolation and approximation, numerical ODE methods including Euler, Runge-Kutta and multistep schemes, numerical PDE methods including finite difference, finite element, finite volume, spectral, boundary-element and method-of-lines formulations, numerical optimisation, meshes, grids and adaptive refinement, floating-point arithmetic, roundoff, truncation, discretisation and iteration error, conditioning, numerical stability, consistency, convergence, tolerances, verification, validation, benchmarking and reproducibility."
}

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

}

END_FLOW