Numerical Methods Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Methods Ontology within the Kireth Research Semantic Library. Numerical methods are algorithmic procedures for approximating solutions to mathematical problems when exact symbolic solutions are unavailable, inefficient or unnecessary. This ontology supports method classification, direct and iterative algorithms, root finding, linear systems, interpolation, differentiation, integration, ordinary and partial differential equation methods, optimisation, eigenvalue computation, adaptive procedures, stopping criteria, convergence, stability, conditioning, accuracy and error control. It provides the operational bridge between numerical-analysis theory and executable computational models.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalMethod
 ENTITY_CLASS = ComputationalApproximationProcedure
 PRIMARY_CONTEXT = NumericalAnalysis
 DEFINITION = "A numerical method is an algorithmic procedure for obtaining an approximate computational solution to a mathematical problem."
 SEMANTIC_ROLE = "Provides the machine-readable framework for selecting, executing, comparing and validating numerical algorithms according to problem type, accuracy, convergence, stability, conditioning and computational cost."
}

SCOPE {
 INCLUDE = [
  NumericalMethod,
  DirectMethod,
  IterativeMethod,
  DeterministicMethod,
  StochasticNumericalMethod,
  RootFindingMethod,
  BisectionMethod,
  NewtonMethod,
  SecantMethod,
  FixedPointIteration,
  BrentMethod,
  LinearSystemMethod,
  GaussianElimination,
  LUFactorisation,
  QRFactorisation,
  CholeskyFactorisation,
  JacobiMethod,
  GaussSeidelMethod,
  ConjugateGradientMethod,
  GMRES,
  Preconditioning,
  EigenvalueMethod,
  PowerIteration,
  QRAlgorithm,
  InterpolationMethod,
  LagrangeInterpolation,
  NewtonInterpolation,
  SplineInterpolation,
  NumericalDifferentiationMethod,
  FiniteDifferenceMethod,
  NumericalIntegrationMethod,
  TrapezoidalRule,
  SimpsonsRule,
  GaussianQuadrature,
  MonteCarloIntegration,
  ODEMethod,
  EulerMethod,
  RungeKuttaMethod,
  MultistepMethod,
  PDEMethod,
  FiniteDifferencePDEMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod,
  NumericalOptimisationMethod,
  GradientDescent,
  NewtonOptimisation,
  QuasiNewtonMethod,
  AdaptiveMethod,
  ErrorEstimator,
  StoppingCriterion
 ]

 EXCLUDE_AS_PRIMARY = [
  NumericalAnalysisTheoryWithoutAlgorithm,
  ExactSymbolicMethodWithoutApproximation,
  GenericAlgorithmWithoutMathematicalApproximationGoal,
  StatisticalLearningMethodUnlessUsedAsNumericalSolver
 ]

 DISAMBIGUATION_RULE =
  "When a computational procedure is chosen to approximate a root, linear-system solution, derivative, integral, differential-equation solution, eigenvalue or optimum, interpret it as a numerical method."
}

CORE_CONCEPTS {

 NumericalMethod {
  definition = "An algorithmic procedure for approximating a mathematical solution or quantity."
 }

 DirectMethod {
  definition = "A numerical method intended to produce a solution in a finite sequence of operations in exact arithmetic."
 }

 IterativeMethod {
  definition = "A numerical method that generates a sequence of approximations intended to converge to a solution."
 }

 RootFindingMethod {
  definition = "A numerical method for approximating solutions of f(x)=0."
 }

 LinearSystemMethod {
  definition = "A numerical method for solving A*x=b."
 }

 InterpolationMethod {
  definition = "A method for constructing a function passing through or approximating known data values."
 }

 NumericalDifferentiationMethod {
  definition = "A method for approximating derivatives from function values or sampled data."
 }

 NumericalIntegrationMethod {
  definition = "A method for approximating definite integrals."
 }

 ODEMethod {
  definition = "A method for approximating solutions of ordinary differential equations."
 }

 PDEMethod {
  definition = "A method for approximating solutions of partial differential equations."
 }

 NumericalOptimisationMethod {
  definition = "A method for approximating minima or maxima of objective functions."
 }

 AdaptiveMethod {
  definition = "A method that dynamically changes step size, mesh resolution, order or computational effort according to error information."
 }

 StoppingCriterion {
  definition = "A rule determining when an iterative numerical procedure terminates."
 }
}

RELATIONS {
 NumericalMethod --is_entity_of--> NumericalAnalysis
 NumericalMethod --solves--> NumericalProblem
 DirectMethod --is_special_case_of--> NumericalMethod
 IterativeMethod --is_special_case_of--> NumericalMethod
 RootFindingMethod --is_special_case_of--> NumericalMethod
 LinearSystemMethod --is_special_case_of--> NumericalMethod
 InterpolationMethod --is_special_case_of--> NumericalMethod
 NumericalDifferentiationMethod --is_special_case_of--> NumericalMethod
 NumericalIntegrationMethod --is_special_case_of--> NumericalMethod
 ODEMethod --is_special_case_of--> NumericalMethod
 PDEMethod --is_special_case_of--> NumericalMethod
 NumericalOptimisationMethod --is_special_case_of--> NumericalMethod
 IterativeMethod --uses--> StoppingCriterion
 AdaptiveMethod --uses--> ErrorEstimator
 Preconditioning --modifies--> LinearSystem
 NumericalMethod --has_property--> Accuracy
 NumericalMethod --has_property--> Stability
 NumericalMethod --may_have--> ConvergenceRate
 NumericalMethod --incurs--> ComputationalCost
}

OPERATORS {
 APPLY_METHOD(method,problem,input_data) :=
  numerical_approximation

 ITERATE(x_k,update_rule) :=
  x_{k+1}=update_rule(x_k)

 BISECTION_UPDATE(a,b,f) :=
  choose_subinterval_containing_sign_change

 NEWTON_UPDATE(x,f,fprime) :=
  x-f(x)/fprime(x)
  WHEN fprime(x)!=0

 SECANT_UPDATE(x0,x1,f) :=
  x1-f(x1)*(x1-x0)/(f(x1)-f(x0))
  WHEN denominator_nonzero

 FIXED_POINT_UPDATE(x,g) :=
  g(x)

 LINEAR_RESIDUAL(A,x,b) :=
  b-A*x

 GRADIENT_DESCENT_UPDATE(x,alpha,grad_f) :=
  x-alpha*grad_f(x)

 NEWTON_OPTIMISATION_UPDATE(x,H,grad_f) :=
  x-H(x)^(-1)*grad_f(x)
  WHEN Hessian_invertible

 EULER_STEP(y,t,h,f) :=
  y+h*f(t,y)

 RK4_STEP(y,t,h,f) :=
  classical_fourth_order_Runge_Kutta_update

 ADAPT_STEP(h,error,tolerance,p) :=
  scaled_new_step_based_on_error_ratio_and_order_p
}

DEFINITIONS {
 D1 = "Numerical methods are selected according to problem structure and accuracy requirements."
 D2 = "Direct and iterative methods are distinct algorithmic classes."
 D3 = "Iterative methods require stopping criteria."
 D4 = "Convergence speed and per-iteration cost must both be considered."
 D5 = "Numerical stability may limit usable step size or formulation."
 D6 = "Conditioning of the underlying problem affects achievable accuracy."
 D7 = "Adaptive methods allocate more effort where estimated error is larger."
 D8 = "Higher formal order does not guarantee better results at all resolutions."
 D9 = "Preconditioning changes solver behaviour without changing the target solution under proper construction."
 D10 = "Method choice is part of numerical reasoning, not merely implementation."
}

AXIOMS {
 A1_PROBLEM_METHOD_MATCH:
  NumericalMethod must be compatible with the mathematical problem class

 A2_APPROXIMATION:
  NumericalMethod returns an exact or approximate computational representation of the requested target

 A3_ITERATIVE_TERMINATION:
  IterativeMethod requires a termination rule or finite iteration cap

 A4_CONVERGENCE:
  Iterative claims require evidence that approximation error decreases under the method's assumptions

 A5_STABILITY:
  Numerical execution must control relevant perturbation growth

 A6_COST:
  Numerical method assessment includes computational resources as well as accuracy

 A7_TOLERANCE:
  Stopping and adaptive decisions depend on explicit numerical tolerances

 A8_VERIFICATION:
  Numerical method output should be supported by residual, error, benchmark or refinement evidence
}

REASONING {

 R1_METHOD_CLASSIFICATION {
  INPUT = candidate_method
  IDENTIFY = direct_iterative_root_linear_interpolation_quadrature_ODE_PDE_optimisation_or_eigenvalue class
  RETURN = method_class
 }

 R2_METHOD_SELECTION {
  INPUT = problem_structure
  IDENTIFY = dimension_sparsity_smoothness_stiffness_symmetry_positive_definiteness_and_accuracy target
  SELECT = compatible_method_family
  RETURN = recommended_method
 }

 R3_ROOT_METHOD_SELECTION {
  INPUT = f_and_available_information
  IF sign_change_interval_available
   SELECT = Bisection_or_Brent
  ELSE IF derivative_available_and_initial_guess_good
   SELECT = Newton
  ELSE IF two_initial_guesses_available
   SELECT = Secant
  ELSE
   CONSIDER = FixedPointIteration
  RETURN = root_method
 }

 R4_LINEAR_SOLVER_SELECTION {
  INPUT = matrix_A
  IF small_or_dense
   SELECT = direct_factorisation
  ELSE IF sparse_SPD
   SELECT = ConjugateGradient
  ELSE IF sparse_general
   SELECT = GMRES_or_related method
  IDENTIFY = preconditioning need
  RETURN = solver_strategy
 }

 R5_QUADRATURE_SELECTION {
  INPUT = integrand_interval_and_regularities
  IDENTIFY = smoothness_singularities_periodicity_and_dimension
  SELECT = trapezoidal_Simpson_Gaussian_adaptive_or_MonteCarlo method
  RETURN = integration_method
 }

 R6_ODE_SELECTION {
  INPUT = ODE_system
  IDENTIFY = stiffness_accuracy_and_event requirements
  SELECT = explicit_implicit_single_step_or_multistep method
  RETURN = ODE_strategy
 }

 R7_PDE_SELECTION {
  INPUT = PDE_type_geometry_and_conservation requirements
  IDENTIFY = elliptic_parabolic_hyperbolic_or_mixed
  SELECT = finite_difference_finite_element_finite_volume_or_spectral method
  RETURN = PDE_strategy
 }

 R8_STOPPING_REASONING {
  INPUT = iterative_method
  MONITOR = residual_step_change_objective_change_or_error estimate
  COMPARE = tolerance
  RETURN = continue_or_stop
 }

 R9_ADAPTIVE_REASONING {
  INPUT = local_error_estimate
  ADJUST = step_mesh_or_order
  VERIFY = tolerance_target
  RETURN = adapted_method_state
 }

 R10_METHOD_COMPARISON {
  INPUT = candidate_methods
  COMPARE = accuracy_stability_convergence_cost_memory_robustness_and_parallelism
  RETURN = method_tradeoff_profile
 }
}

CONSTRAINTS {
 C1 = "A numerical method must match the mathematical problem class."
 C2 = "Newton-type methods require suitable derivatives or approximations."
 C3 = "Iterative stopping criteria must account for problem scaling."
 C4 = "Small residual does not necessarily imply small forward error."
 C5 = "Explicit time-stepping may have stability restrictions."
 C6 = "Finite-difference formulas require sufficient smoothness for stated order."
 C7 = "Gaussian quadrature assumptions differ from Monte Carlo integration assumptions."
 C8 = "Sparse and dense linear systems should not be treated identically for method selection."
 C9 = "Adaptive algorithms require reliable error estimators."
 C10 = "Computational cost comparisons must use comparable accuracy targets."
}

SEMANTIC_EQUIVALENCE {
 "NumericalMethod" <=> "ComputationalApproximationProcedure"
 "DirectMethod" <=> "FiniteOperationNumericalSolver"
 "IterativeMethod" <=> "SuccessiveApproximationMethod"
 "RootFindingMethod" <=> "ZeroApproximationAlgorithm"
 "LinearSystemMethod" <=> "AxEqualsBSolver"
 "AdaptiveMethod" <=> "ErrorControlledVariableResolutionMethod"
}

VALIDATION {
 V1 = "Method is compatible with problem type."
 V2 = "Method assumptions are satisfied."
 V3 = "Stopping criteria are explicit."
 V4 = "Tolerance is meaningful relative to scaling."
 V5 = "Convergence evidence supports convergence claims."
 V6 = "Stability restrictions are respected."
 V7 = "Error estimates align with method order and smoothness assumptions."
 V8 = "Preconditioners preserve the target problem."
 V9 = "Computational cost is evaluated at comparable accuracy."
 V10 = "Approximate result status is explicit."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_METHOD_DEFINITION = 0.99
 METHOD_CLASSIFICATION_REASONING = 0.99
 METHOD_SELECTION_REASONING = 0.98
 ROOT_METHOD_REASONING = 0.99
 LINEAR_SOLVER_REASONING = 0.98
 ODE_METHOD_REASONING = 0.98
 PDE_METHOD_REASONING = 0.97
 ADAPTIVE_REASONING = 0.98
 METHOD_COMPARISON_REASONING = 0.98

 POLICY =
  "Reduce confidence when problem structure, smoothness, stiffness, conditioning, matrix properties, tolerance, computational scale or error requirements are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalMethodReasoning,
  MethodClassification,
  MethodSelection,
  RootFindingMethodSelection,
  LinearSolverSelection,
  InterpolationMethodSelection,
  QuadratureMethodSelection,
  NumericalDifferentiationMethodSelection,
  ODESolverSelection,
  PDESolverSelection,
  OptimisationMethodSelection,
  AdaptiveMethodReasoning,
  StoppingCriterionReasoning,
  MethodComparison,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "numerical methods" -> NumericalMethod
  "numerical method" -> NumericalMethod
  "direct method" -> DirectMethod
  "iterative method" -> IterativeMethod
  "root-finding method" -> RootFindingMethod
  "linear solver" -> LinearSystemMethod
  "quadrature method" -> NumericalIntegrationMethod
  "ODE solver" -> ODEMethod
  "PDE solver" -> PDEMethod
  "adaptive method" -> AdaptiveMethod
  "stopping criterion" -> StoppingCriterion
 }

 INTERPRETATION_ORDER = [
  detect_numerical_method_context,
  identify mathematical_problem_structure_data_accuracy_and_cost requirements,
  classify method_family,
  verify method assumptions,
  configure initialisation_tolerance_step_mesh_or_preconditioner,
  execute or reason over method,
  assess residual_error_convergence_stability_and_cost,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("numerical method")
  OR asks_for_algorithm_to_approximately_solve_mathematical_problem
  THEN activate(NumericalMethodsOntology)

 E2:
  IF nonlinear_root_problem
  THEN choose method according_to bracket_derivative_and_initialisation information

 E3:
  IF linear_system
  THEN inspect matrix_size_sparsity_symmetry_definiteness_and_conditioning

 E4:
  IF ODE_problem
  THEN inspect stiffness_and_error_control requirements

 E5:
  IF PDE_problem
  THEN classify PDE_and_geometry_before discretisation selection

 E6:
  IF iterative_method
  THEN define stopping_criterion_and_iteration cap

 E7:
  IF adaptive_method
  THEN require error_estimate

 E8:
  IF comparing_methods
  THEN compare at equivalent accuracy_or_tolerance targets

 E9:
  IF numerical_output_used_for_verification
  THEN preserve method_configuration_and_convergence evidence
}

RECURSION {
 ENTRY = NumericalMethod

 EXPAND(NumericalMethod) -> [
  DirectMethod,
  IterativeMethod,
  RootFindingMethod,
  LinearSystemMethod,
  EigenvalueMethod,
  InterpolationMethod,
  NumericalDifferentiationMethod,
  NumericalIntegrationMethod,
  ODEMethod,
  PDEMethod,
  NumericalOptimisationMethod,
  AdaptiveMethod,
  ErrorEstimator,
  StoppingCriterion,
  Preconditioning
 ]

 EXPAND(RootFindingMethod) -> [
  BisectionMethod,
  NewtonMethod,
  SecantMethod,
  FixedPointIteration,
  BrentMethod
 ]

 EXPAND(LinearSystemMethod) -> [
  GaussianElimination,
  LUFactorisation,
  QRFactorisation,
  CholeskyFactorisation,
  JacobiMethod,
  GaussSeidelMethod,
  ConjugateGradientMethod,
  GMRES,
  Preconditioning
 ]

 EXPAND(IntegrationMethods) -> [
  TrapezoidalRule,
  SimpsonsRule,
  GaussianQuadrature,
  AdaptiveQuadrature,
  MonteCarloIntegration
 ]

 EXPAND(DifferentialEquationMethods) -> [
  EulerMethod,
  RungeKuttaMethod,
  MultistepMethod,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod
 ]

 STOP_CONDITION =
  "Stop when the numerical problem, selected method, assumptions, initialisation, tolerance, convergence, stability, error and computational-cost tradeoffs are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Analysis"

 IMMEDIATE_CONTEXTS = [
  "Numerical Analysis Ontology",
  "Numerical Analysis",
  "Computational Model Ontology",
  "Model Verification Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Numerical Analysis Ontology",
  "Numerical Analysis",
  "Applied Mathematics Ontologies",
  "Computational Model Ontology",
  "Model Verification Ontology",
  "Scientific Computing Ontologies",
  "Linear Algebra Ontologies",
  "Calculus & Analysis Ontologies",
  "Differential Equations Ontologies",
  "Optimisation Ontologies",
  "Approximation Theory Ontologies",
  "Computational Mathematics Ontologies"
 ]

 ROUTE_RULES = [
  "Numerical Methods -> Numerical Analysis Ontology for formal numerical semantics",
  "Numerical Methods -> Numerical Analysis for parent theory",
  "Numerical Methods -> Computational Model for executable implementation",
  "Numerical Methods -> Model Verification for convergence and correctness evidence",
  "Numerical Methods -> Linear Algebra for matrix solvers and eigenmethods",
  "Numerical Methods -> Calculus & Analysis for differentiation and quadrature",
  "Numerical Methods -> Differential Equations for ODE and PDE methods",
  "Numerical Methods -> Optimisation for minimisation and maximisation methods",
  "Numerical Methods -> Approximation Theory for interpolation and approximation",
  "Numerical Methods -> Scientific Computing for computational-scale execution"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical algorithms, solver families or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve algorithmic approximation semantics.",
  "Preserve direct-versus-iterative distinction.",
  "Preserve problem-method compatibility.",
  "Preserve tolerance and stopping semantics.",
  "Preserve stability and convergence awareness.",
  "Preserve adaptive error-control semantics.",
  "Preserve comparable-accuracy method comparison.",
  "Preserve machine-readable numerical-method semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "A numerical method is an algorithmic procedure for approximating the solution of a mathematical problem."

 CLASSIFICATION_SUMMARY =
  "Numerical methods include direct, iterative, root-finding, linear-system, interpolation, quadrature, differential-equation and optimisation methods."

 ROOT_SUMMARY =
  "Root-finding methods include bisection, Newton, secant, fixed-point and hybrid approaches."

 LINEAR_SUMMARY =
  "Linear-system methods include direct factorisations and iterative Krylov or stationary methods."

 INTEGRATION_SUMMARY =
  "Numerical integration methods approximate definite integrals using weighted samples or stochastic sampling."

 ODE_SUMMARY =
  "ODE methods advance dynamic states through time using explicit, implicit, single-step or multistep schemes."

 PDE_SUMMARY =
  "PDE methods discretise spatial and temporal structure using finite difference, finite element, finite volume or spectral formulations."

 ADAPTIVE_SUMMARY =
  "Adaptive methods vary computational effort according to estimated local or global error."

 SELECTION_SUMMARY =
  "Method selection depends on problem structure, accuracy, stability, conditioning, robustness and computational cost."
}

FLOW {
 INPUT
 -> detect_numerical_method_context
 -> identify mathematical_problem_class_structure_dimension_smoothness_stiffness_conditioning_accuracy_and_cost requirements
 -> classify numerical_method family
 -> select compatible algorithm
 -> configure initial_guess_bracket_step_mesh_preconditioner_tolerance_and_stopping criterion
 -> execute_or_analyse numerical_method
 -> compute residual_error_and_convergence indicators
 -> assess stability_accuracy_robustness_and_cost
 -> route to numerical_analysis_ontology numerical_analysis computational_model model_verification linear_algebra calculus differential_equations optimisation approximation_theory_or_scientific_computing ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Methods Ontology defines algorithmic procedures for approximate mathematical solution. It supports direct and iterative methods, nonlinear root finding, linear-system solvers, matrix factorisations, eigenvalue methods, interpolation, numerical differentiation and integration, ODE and PDE solvers, optimisation methods, adaptivity, preconditioning, stopping criteria, convergence, stability, accuracy and computational tradeoff reasoning."
}

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

}

END_FLOW