Numerical Analysis Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Analysis Ontology within the Kireth Research Semantic Library. It formalises numerical analysis as a machine-readable ontology of approximation, discretisation, floating-point arithmetic, conditioning, stability, consistency, convergence, error estimation, iterative methods, numerical linear algebra, interpolation, differentiation, quadrature, differential-equation solvers and adaptive computation. It sits beneath the Numerical Analysis parent layer and provides a structured reasoning framework for selecting, evaluating and validating numerical methods.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalAnalysisOntology
 ENTITY_CLASS = NumericalApproximationOntology
 PRIMARY_CONTEXT = NumericalAnalysis
 DEFINITION = "The Numerical Analysis Ontology is a formal semantic framework for representing numerical methods, approximation error, conditioning, stability, convergence, finite precision and computational solution strategies."
 SEMANTIC_ROLE = "Provides machine-readable entities and reasoning relations for classifying numerical problems, selecting methods, analysing error, evaluating convergence and connecting numerical algorithms to mathematical models."
}

SCOPE {
 INCLUDE = [
  NumericalAnalysisOntology,
  NumericalProblem,
  NumericalMethod,
  Approximation,
  Discretisation,
  FloatingPointArithmetic,
  MachinePrecision,
  RoundoffError,
  TruncationError,
  IterationError,
  DataError,
  AbsoluteError,
  RelativeError,
  ForwardError,
  BackwardError,
  ErrorBound,
  ErrorEstimate,
  Conditioning,
  ConditionNumber,
  Stability,
  Consistency,
  Convergence,
  ConvergenceRate,
  OrderOfAccuracy,
  Residual,
  Tolerance,
  RootFinding,
  NumericalLinearAlgebra,
  Interpolation,
  ApproximationTheory,
  NumericalDifferentiation,
  NumericalIntegration,
  Quadrature,
  ODESolver,
  PDESolver,
  NumericalOptimisation,
  AdaptiveMethod,
  Preconditioning,
  ScientificComputing
 ]

 EXCLUDE_AS_PRIMARY = [
  ExactSymbolicMathematicsWithoutNumericalApproximation,
  GenericProgrammingWithoutNumericalSemantics,
  StatisticalInferenceWithoutNumericalComputationGoal,
  MathematicalModellingWithoutNumericalSolutionContext
 ]

 DISAMBIGUATION_RULE =
  "When an approximate computational solution is analysed in terms of error, conditioning, stability, consistency, convergence, tolerance or finite precision, interpret the context through the Numerical Analysis Ontology."
}

CORE_CONCEPTS {

 NumericalAnalysisOntology {
  definition = "The ontology organising the entities, relations and reasoning patterns of numerical analysis."
 }

 NumericalProblem {
  definition = "A mathematical problem posed for approximate computational solution."
 }

 NumericalMethod {
  definition = "An algorithmic procedure for approximating a mathematical target."
 }

 Approximation {
  definition = "A computed quantity representing an exact or ideal mathematical object within some error context."
 }

 Discretisation {
  definition = "Replacement of a continuous or large problem by a finite computational representation."
 }

 FloatingPointArithmetic {
  definition = "Finite-precision arithmetic governed by machine number representation and rounding."
 }

 MachinePrecision {
  definition = "A characteristic scale describing floating-point rounding resolution."
 }

 Conditioning {
  definition = "Sensitivity of the mathematical problem to perturbations in its input data."
 }

 Stability {
  definition = "Sensitivity of a numerical algorithm to computational perturbations."
 }

 Consistency {
  definition = "The property that the discrete method approximates the intended mathematical equations under refinement."
 }

 Convergence {
  definition = "The property that approximations approach the target solution under valid iteration or refinement."
 }

 Residual {
  definition = "The discrepancy obtained by substituting an approximate solution into the discrete or continuous equations."
 }

 Tolerance {
  definition = "A declared numerical threshold used in stopping, acceptance or refinement criteria."
 }
}

RELATIONS {
 NumericalAnalysisOntology --is_child_of--> NumericalAnalysis
 NumericalProblem --is_solved_by--> NumericalMethod
 NumericalMethod --produces--> Approximation
 NumericalMethod --may_require--> Discretisation
 FloatingPointArithmetic --introduces--> RoundoffError
 Discretisation --introduces--> TruncationError
 IterativeMethod --introduces--> IterationError
 Conditioning --describes--> NumericalProblem
 Stability --describes--> NumericalMethod
 Consistency --describes--> DiscretisationScheme
 Convergence --describes--> ApproximationSequence
 OrderOfAccuracy --describes--> ErrorDecay
 Residual --supports--> SolverAssessment
 Tolerance --controls--> IterativeTermination
 Preconditioning --improves--> NumericalSolverBehaviour
 AdaptiveMethod --uses--> ErrorEstimate
}

OPERATORS {
 ABSOLUTE_ERROR(exact,approx) :=
  abs(exact-approx)

 RELATIVE_ERROR(exact,approx) :=
  abs(exact-approx)/abs(exact)
  WHEN exact!=0

 FORWARD_ERROR(x_exact,x_num) :=
  norm(x_num-x_exact)

 BACKWARD_ERROR(problem,x_num) :=
  smallest_input_perturbation_for_which_x_num_is_exact

 CONDITION_NUMBER(A) :=
  norm(A)*norm(A^-1)
  WHEN A_is_invertible

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

 CONVERGENCE_RATE(e_h,e_h2,r) :=
  log(e_h/e_h2)/log(r)

 CHECK_CONVERGENCE(sequence,tolerance) :=
  stopping_test_under_declared criterion

 CHECK_STABILITY(method,perturbation_model) :=
  perturbation_amplification_assessment

 CHECK_CONSISTENCY(discrete_operator,continuous_operator,h) :=
  limit_of_local_discretisation_error_as_h_to_zero

 ADAPT_RESOLUTION(error_estimate,tolerance) :=
  refine_or_coarsen according_to_error
}

DEFINITIONS {
 D1 = "Numerical analysis distinguishes problem sensitivity from algorithm sensitivity."
 D2 = "Conditioning is a property of the mathematical problem."
 D3 = "Stability is a property of the numerical method."
 D4 = "Consistency concerns approximation of equations."
 D5 = "Convergence concerns approximation of solutions."
 D6 = "Forward and backward errors provide different notions of numerical accuracy."
 D7 = "Residual size is not generally identical to forward error."
 D8 = "Finite precision imposes limits on attainable accuracy."
 D9 = "Order of accuracy describes asymptotic error decay."
 D10 = "Adaptive methods use numerical evidence to redistribute computational effort."
}

AXIOMS {
 A1_APPROXIMATION:
  NumericalMethod maps a mathematical problem to an approximation

 A2_FINITE_PRECISION:
  Floating-point computation introduces rounding effects

 A3_CONDITIONING:
  Ill-conditioned problems amplify input perturbations

 A4_STABILITY:
  Stable algorithms control computational perturbation growth

 A5_CONSISTENCY:
  Valid discretisations approach the intended equations under refinement

 A6_CONVERGENCE:
  Convergent schemes approach the mathematical solution under appropriate assumptions

 A7_ERROR_CONTEXT:
  Numerical results require an error or tolerance context

 A8_VERIFIABILITY:
  Numerical reliability should be supported by residual, reference, benchmark or refinement evidence
}

REASONING {

 R1_ENTITY_EXTRACTION {
  INPUT = numerical_problem_description
  IDENTIFY = problem_type
  IDENTIFY = data
  IDENTIFY = target_quantity
  IDENTIFY = method
  IDENTIFY = precision_and_tolerance
  RETURN = structured_numerical_entities
 }

 R2_PROBLEM_CLASSIFICATION {
  INPUT = structured_problem
  CLASSIFY = root_linear_system_eigenvalue_interpolation_integration_differentiation_ODE_PDE_or_optimisation
  RETURN = numerical_problem_class
 }

 R3_METHOD_SELECTION {
  INPUT = problem_class_and_structure
  IDENTIFY = smoothness_sparsity_stiffness_conditioning_dimension_and_accuracy need
  SELECT = compatible numerical method
  RETURN = method_strategy
 }

 R4_ERROR_DECOMPOSITION {
  INPUT = numerical_computation
  IDENTIFY = data_error
  IDENTIFY = discretisation_or_truncation_error
  IDENTIFY = iteration_error
  IDENTIFY = roundoff_error
  RETURN = error_budget
 }

 R5_CONDITIONING_ANALYSIS {
  INPUT = mathematical_problem
  PERTURB = inputs
  MEASURE = change_in_exact_solution
  RETURN = conditioning_profile
 }

 R6_STABILITY_ANALYSIS {
  INPUT = numerical_method
  PERTURB = intermediate_data_or_state
  ANALYSE = propagation
  RETURN = stability_profile
 }

 R7_CONVERGENCE_ANALYSIS {
  INPUT = approximation_sequence
  COMPUTE = differences_or_errors
  ESTIMATE = asymptotic convergence rate
  RETURN = convergence_profile
 }

 R8_RESIDUAL_REASONING {
  INPUT = approximate_solution
  COMPUTE = equation residual
  NORMALISE = when required
  COMPARE = tolerance_and_conditioning
  RETURN = residual_assessment
 }

 R9_ADAPTIVE_REASONING {
  INPUT = local_or_global_error_estimates
  COMPARE = tolerance
  REFINE = high_error regions_or_steps
  COARSEN = overresolved regions_or_steps
  RETURN = adapted_computational representation
 }

 R10_NUMERICAL_RELIABILITY {
  INPUT = method_solution_and_evidence
  COMBINE = conditioning_stability_convergence_error_and_residual information
  RETURN = numerical_reliability_status
 }
}

CONSTRAINTS {
 C1 = "Conditioning and stability must not be conflated."
 C2 = "Consistency and convergence must not be conflated."
 C3 = "Residual and forward error must not be treated as identical."
 C4 = "Relative error requires nonzero reference scale."
 C5 = "Observed convergence order requires asymptotic refinement."
 C6 = "Solver tolerances must be interpreted relative to scaling and conditioning."
 C7 = "Floating-point precision limits attainable accuracy."
 C8 = "Adaptive refinement requires meaningful error estimates."
 C9 = "Numerical method assumptions must match problem structure."
 C10 = "Approximate results must not be presented as exact without justification."
}

SEMANTIC_EQUIVALENCE {
 "NumericalAnalysisOntology" <=> "FormalNumericalApproximationOntology"
 "NumericalMethod" <=> "ComputationalApproximationAlgorithm"
 "Conditioning" <=> "ProblemSensitivity"
 "Stability" <=> "AlgorithmPerturbationSensitivity"
 "Consistency" <=> "EquationApproximationCorrectness"
 "Convergence" <=> "SolutionApproximationApproachesTarget"
}

VALIDATION {
 V1 = "Numerical problem is classified."
 V2 = "Method assumptions are identified."
 V3 = "Error measure is appropriate."
 V4 = "Conditioning is considered."
 V5 = "Stability is considered."
 V6 = "Convergence evidence supports convergence claims."
 V7 = "Tolerance and precision are explicit."
 V8 = "Residual interpretation accounts for conditioning."
 V9 = "Adaptive estimates are credible."
 V10 = "Approximate-versus-exact status is preserved."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_ANALYSIS_ONTOLOGY_DEFINITION = 0.99
 PROBLEM_CLASSIFICATION_REASONING = 0.99
 METHOD_SELECTION_REASONING = 0.98
 ERROR_DECOMPOSITION_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 STABILITY_REASONING = 0.98
 CONVERGENCE_REASONING = 0.99
 RELIABILITY_REASONING = 0.98

 POLICY =
  "Reduce confidence when numerical method, problem conditioning, precision, tolerance, refinement evidence, residual scaling or method assumptions are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalAnalysisOntologyReasoning,
  NumericalProblemClassification,
  NumericalMethodSelection,
  ErrorDecomposition,
  ConditioningAnalysis,
  StabilityAnalysis,
  ConsistencyAnalysis,
  ConvergenceAnalysis,
  ResidualReasoning,
  AdaptiveMethodReasoning,
  NumericalReliabilityAssessment,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "numerical analysis ontology" -> NumericalAnalysisOntology
  "numerical problem" -> NumericalProblem
  "numerical method" -> NumericalMethod
  "roundoff error" -> RoundoffError
  "truncation error" -> TruncationError
  "forward error" -> ForwardError
  "backward error" -> BackwardError
  "condition number" -> ConditionNumber
  "stability" -> Stability WHEN numerical_context
  "consistency" -> Consistency WHEN numerical_context
  "convergence" -> Convergence WHEN numerical_context
 }

 INTERPRETATION_ORDER = [
  detect_numerical_analysis_ontology_context,
  extract numerical_problem_method_data_precision_tolerance_and_target,
  classify problem_and_algorithm,
  identify conditioning_stability_consistency_convergence_and_error context,
  compute_or_infer numerical_quality properties,
  verify residual_refinement_precision_and_assumption constraints,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("numerical analysis ontology")
  OR formal_numerical_method_semantics_context
  THEN activate(NumericalAnalysisOntology)

 E2:
  IF numerical_problem_given
  THEN classify problem_type before method selection

 E3:
  IF approximation_reported
  THEN preserve exact_vs_approximate status

 E4:
  IF convergence_claimed
  THEN require refinement_or_iteration evidence

 E5:
  IF solver_residual_small
  THEN do_not infer small_forward_error_without considering conditioning

 E6:
  IF ill_conditioned_problem
  THEN distinguish unavoidable_problem sensitivity_from algorithm instability

 E7:
  IF high_precision requested
  THEN consider floating_point limits

 E8:
  IF adaptive_method used
  THEN require error_estimate_or_indicator

 E9:
  IF numerical_method output used_for_model_verification
  THEN route to model_verification semantics
}

RECURSION {
 ENTRY = NumericalAnalysisOntology

 EXPAND(NumericalAnalysisOntology) -> [
  NumericalProblem,
  NumericalMethod,
  Approximation,
  Discretisation,
  FloatingPointArithmetic,
  MachinePrecision,
  RoundoffError,
  TruncationError,
  IterationError,
  AbsoluteError,
  RelativeError,
  ForwardError,
  BackwardError,
  Conditioning,
  ConditionNumber,
  Stability,
  Consistency,
  Convergence,
  ConvergenceRate,
  OrderOfAccuracy,
  Residual,
  Tolerance,
  RootFinding,
  NumericalLinearAlgebra,
  Interpolation,
  NumericalDifferentiation,
  NumericalIntegration,
  ODESolver,
  PDESolver,
  NumericalOptimisation,
  AdaptiveMethod,
  Preconditioning,
  ScientificComputing
 ]

 EXPAND(ErrorStructure) -> [
  DataError,
  TruncationError,
  IterationError,
  RoundoffError,
  ForwardError,
  BackwardError,
  ErrorBound,
  ErrorEstimate
 ]

 EXPAND(NumericalQuality) -> [
  Conditioning,
  Stability,
  Consistency,
  Convergence,
  OrderOfAccuracy,
  Residual,
  Tolerance
 ]

 EXPAND(MethodFamilies) -> [
  RootFinding,
  NumericalLinearAlgebra,
  Interpolation,
  Quadrature,
  NumericalDifferentiation,
  ODESolver,
  PDESolver,
  NumericalOptimisation
 ]

 STOP_CONDITION =
  "Stop when the numerical problem, approximation method, error structure, conditioning, stability, consistency, convergence, residual and numerical reliability are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Analysis"

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

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

 ROUTE_RULES = [
  "Numerical Analysis Ontology -> Numerical Analysis for parent numerical semantics",
  "Numerical Analysis Ontology -> Applied Mathematics for application context",
  "Numerical Analysis Ontology -> Computational Model for executable approximations",
  "Numerical Analysis Ontology -> Model Verification for solution and convergence assessment",
  "Numerical Analysis Ontology -> Scientific Computing for implementation and scale",
  "Numerical Analysis Ontology -> Linear Algebra for matrix numerical methods",
  "Numerical Analysis Ontology -> Calculus & Analysis for quadrature and differentiation",
  "Numerical Analysis Ontology -> Differential Equations for time and space discretisation",
  "Numerical Analysis Ontology -> Optimisation for numerical minimisation",
  "Numerical Analysis Ontology -> Computational Mathematics for broader algorithmic reasoning"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical entities, algorithm classes or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve numerical approximation semantics.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve consistency-versus-convergence distinction.",
  "Preserve forward-versus-backward error distinction.",
  "Preserve finite-precision semantics.",
  "Preserve residual-context semantics.",
  "Preserve approximate-versus-exact status.",
  "Preserve machine-readable numerical-analysis ontology semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "The Numerical Analysis Ontology formally represents numerical problems, methods, approximations, errors and reliability properties."

 PROBLEM_SUMMARY =
  "Numerical problems are classified by mathematical target and computational structure."

 ERROR_SUMMARY =
  "Numerical error may arise from data, discretisation, truncation, iteration and finite-precision arithmetic."

 CONDITIONING_SUMMARY =
  "Conditioning measures sensitivity of the mathematical problem to input perturbations."

 STABILITY_SUMMARY =
  "Stability measures how a numerical algorithm responds to computational perturbations."

 CONSISTENCY_SUMMARY =
  "Consistency measures whether the discrete equations approach the intended equations."

 CONVERGENCE_SUMMARY =
  "Convergence measures whether approximations approach the intended solution."

 RESIDUAL_SUMMARY =
  "Residuals quantify equation satisfaction but require conditioning-aware interpretation."

 RELIABILITY_SUMMARY =
  "Numerical reliability combines error, conditioning, stability, convergence, residual and precision evidence."
}

FLOW {
 INPUT
 -> detect_numerical_analysis_ontology_context
 -> identify numerical_problem_target_method_discretisation_precision_tolerance_and_reference information
 -> classify problem_and_method family
 -> decompose numerical_errors
 -> analyse conditioning
 -> analyse stability_and_consistency
 -> assess convergence_and_order
 -> compute residual_and_error indicators
 -> evaluate numerical_reliability
 -> route to numerical_analysis applied_mathematics computational_model model_verification scientific_computing linear_algebra calculus differential_equations optimisation_or_computational_mathematics ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Analysis Ontology formalises numerical approximation as a structured semantic system. It represents numerical problems, algorithms, discretisation, floating-point arithmetic, forward and backward error, conditioning, stability, consistency, convergence, residuals, tolerances, adaptive methods and the major families of numerical computation in a machine-readable reasoning framework."
}

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

}

END_FLOW