Numerical Analysis

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Analysis layer within the Kireth Research Semantic Library. Numerical analysis studies algorithms for approximating mathematical quantities, solving mathematical problems computationally, and understanding the accuracy, stability, convergence, conditioning and error behaviour of those algorithms. This parent ontology links numerical linear algebra, root finding, interpolation, approximation, quadrature, numerical differentiation, ordinary and partial differential equation solvers, optimisation, eigenvalue problems, iterative methods, floating-point arithmetic, error analysis and scientific computing. It provides the semantic routing layer between mathematical models and computational solution methods.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalAnalysis
 ENTITY_CLASS = ComputationalApproximationFramework
 PRIMARY_CONTEXT = AppliedMathematics
 DEFINITION = "Numerical analysis is the study of algorithms for approximating mathematical solutions and quantifying the effects of discretisation, finite precision, conditioning, stability and convergence."
 SEMANTIC_ROLE = "Provides the parent semantic framework for numerical algorithms, approximation error, floating-point effects, linear and nonlinear solvers, interpolation, quadrature, differential-equation methods and numerical reliability."
}

SCOPE {
 INCLUDE = [
  NumericalAnalysis,
  NumericalMethod,
  Approximation,
  Discretisation,
  FloatingPointArithmetic,
  RoundoffError,
  TruncationError,
  AbsoluteError,
  RelativeError,
  ErrorBound,
  Conditioning,
  ConditionNumber,
  Stability,
  Consistency,
  Convergence,
  OrderOfAccuracy,
  RootFinding,
  BisectionMethod,
  NewtonMethod,
  SecantMethod,
  FixedPointIteration,
  NumericalLinearAlgebra,
  LinearSystemSolver,
  DirectMethod,
  IterativeMethod,
  MatrixFactorisation,
  EigenvalueComputation,
  Interpolation,
  PolynomialInterpolation,
  SplineInterpolation,
  ApproximationTheory,
  NumericalDifferentiation,
  NumericalIntegration,
  Quadrature,
  OrdinaryDifferentialEquationSolver,
  PartialDifferentialEquationSolver,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod,
  NumericalOptimisation,
  AdaptiveMethod,
  ScientificComputing
 ]

 EXCLUDE_AS_PRIMARY = [
  ExactSymbolicComputationWithoutApproximation,
  PureMathematicalAnalysisWithoutNumericalAlgorithm,
  GeneralSoftwareEngineeringWithoutMathematicalComputation,
  StatisticalInferenceWithoutNumericalMethodContext
 ]

 DISAMBIGUATION_RULE =
  "When a mathematical problem is solved approximately by algorithm and the context concerns error, stability, convergence, conditioning, discretisation or finite precision, interpret it as numerical analysis."
}

CORE_CONCEPTS {

 NumericalAnalysis {
  definition = "The mathematical study of numerical algorithms and their reliability."
 }

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

 Approximation {
  definition = "A computable quantity intended to represent an exact mathematical object within an error tolerance."
 }

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

 Error {
  definition = "The discrepancy between an exact or reference value and an approximation."
 }

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

 Stability {
  definition = "Sensitivity of a numerical algorithm to perturbations introduced during computation."
 }

 Consistency {
  definition = "The property that the discrete equations approach the intended continuous equations as resolution is refined."
 }

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

 OrderOfAccuracy {
  definition = "The asymptotic rate at which numerical error decreases with resolution."
 }

 FloatingPointArithmetic {
  definition = "Finite-precision arithmetic used by digital computers to approximate real-number calculations."
 }

 AdaptiveMethod {
  definition = "A numerical method that changes resolution, step size or algorithmic effort based on estimated error."
 }
}

RELATIONS {
 NumericalAnalysis --is_branch_of--> AppliedMathematics
 NumericalAnalysis --supports--> ScientificComputing
 NumericalMethod --approximates--> MathematicalSolution
 NumericalMethod --may_use--> Discretisation
 NumericalMethod --has_property--> Stability
 NumericalMethod --has_property--> Consistency
 NumericalMethod --may_have--> Convergence
 NumericalMethod --has--> OrderOfAccuracy
 FloatingPointArithmetic --introduces--> RoundoffError
 Discretisation --introduces--> TruncationError
 Conditioning --describes--> MathematicalProblem
 Stability --describes--> NumericalAlgorithm
 Convergence --depends_on--> NumericalMethod
 AdaptiveMethod --uses--> ErrorEstimate
 RootFinding --solves--> NonlinearEquation
 NumericalLinearAlgebra --solves--> MatrixProblem
 Quadrature --approximates--> Integral
 NumericalDifferentiation --approximates--> Derivative
 DifferentialEquationSolver --approximates--> DifferentialEquationSolution
}

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

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

 CONDITION_NUMBER(A) :=
  ||A||*||A^{-1}||
  WHEN A_is_invertible

 FORWARD_ERROR(exact_solution,computed_solution) :=
  norm(computed_solution-exact_solution)

 BACKWARD_ERROR(problem,computed_solution) :=
  minimum_input_perturbation_making_computed_solution_exact

 CONVERGENCE_RATE(e_h,e_h2,r) :=
  log(e_h/e_h2)/log(r)
  under asymptotic_refinement assumptions

 BISECTION_STEP(a,b,f) :=
  midpoint_and_sign_based_interval_reduction

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

 FIXED_POINT_STEP(x,g) :=
  g(x)

 QUADRATURE_SUM(nodes,weights,f) :=
  sum_i weights_i*f(nodes_i)

 FINITE_DIFFERENCE_DERIVATIVE(f,x,h) :=
  declared_difference_formula

 ADAPT(step,error_estimate,tolerance) :=
  refined_or_coarsened_step_based_on_error
}

DEFINITIONS {
 D1 = "Numerical analysis concerns both algorithms and mathematical guarantees."
 D2 = "Problem conditioning and algorithm stability are distinct."
 D3 = "Forward error measures solution error."
 D4 = "Backward error measures the perturbation to the input problem."
 D5 = "Roundoff error arises from finite-precision arithmetic."
 D6 = "Truncation error arises from replacing an exact process by a finite approximation."
 D7 = "Consistency and stability often combine to support convergence."
 D8 = "Observed convergence order is meaningful primarily in the asymptotic regime."
 D9 = "Adaptive methods use error estimates to allocate computational effort."
 D10 = "Numerical accuracy and computational cost are competing considerations."
}

AXIOMS {
 A1_APPROXIMATION:
  NumericalMethod produces an approximation to a mathematical target

 A2_ERROR:
  Approximation quality is assessed relative to an exact reference, trusted solution or convergent refinement process

 A3_CONDITIONING:
  Ill-conditioned problems can amplify small input perturbations

 A4_STABILITY:
  Stable algorithms control amplification of computational perturbations

 A5_CONVERGENCE:
  Convergent methods approach the intended solution under valid refinement or iteration

 A6_FINITE_PRECISION:
  Digital numerical computation is affected by finite-precision arithmetic

 A7_COST:
  Numerical methods consume finite computational resources

 A8_VERIFICATION:
  Numerical claims require appropriate residual, error, convergence or benchmark evidence
}

REASONING {

 R1_PROBLEM_CLASSIFICATION {
  INPUT = mathematical_problem
  IDENTIFY = linear_system_root_integral_derivative_ODE_PDE_eigenvalue_optimisation_or_approximation
  RETURN = numerical_problem_class
 }

 R2_METHOD_SELECTION {
  INPUT = problem_class_structure_accuracy_requirement_and_cost
  IDENTIFY = smoothness_dimension_sparsity_stiffness_conditioning
  SELECT = compatible_numerical_method
  RETURN = method_strategy
 }

 R3_ERROR_ANALYSIS {
  INPUT = method_and_approximation
  IDENTIFY = truncation_roundoff_iteration_and_data errors
  COMPUTE = available_error_bounds_or_estimates
  RETURN = error_profile
 }

 R4_CONDITIONING_ANALYSIS {
  INPUT = mathematical_problem
  PERTURB = input_data
  MEASURE = solution_sensitivity
  RETURN = conditioning_profile
 }

 R5_STABILITY_ANALYSIS {
  INPUT = numerical_algorithm
  ANALYSE = propagation_of_perturbations
  RETURN = stable_conditionally_stable_or_unstable
 }

 R6_CONVERGENCE_ANALYSIS {
  INPUT = approximation_sequence
  COMPARE = error_under_refinement_or_iteration
  ESTIMATE = convergence_rate
  RETURN = convergence_profile
 }

 R7_ROOT_FINDING {
  INPUT = nonlinear_equation_f(x)=0
  IF bracketing_available
   SELECT = bisection_or_hybrid
  ELSE IF derivative_available_and_good_initial_guess
   SELECT = Newton
  ELSE
   SELECT = secant_or_fixed_point method
  RETURN = root_estimate
 }

 R8_LINEAR_SYSTEM_SOLUTION {
  INPUT = A*x=b
  IDENTIFY = matrix_structure
  SELECT = direct_or_iterative solver
  ANALYSE = conditioning_and_residual
  RETURN = numerical_solution
 }

 R9_ADAPTIVE_REFINEMENT {
  INPUT = local_or_global_error_estimate
  COMPARE = tolerance
  REFINE_OR_COARSEN = discretisation
  RETURN = adaptive_representation
 }

 R10_NUMERICAL_VERIFICATION {
  INPUT = method_and_solution
  CHECK = residuals_reference_cases_refinement_and_tolerance
  RETURN = numerical_reliability_status
 }
}

CONSTRAINTS {
 C1 = "Problem conditioning and algorithm stability must not be conflated."
 C2 = "Residual size does not always equal forward error."
 C3 = "Relative error is undefined when the reference value is zero."
 C4 = "Convergence-rate estimates require meaningful refinement ratios."
 C5 = "Observed order may be misleading outside the asymptotic regime."
 C6 = "Finite-difference step sizes cannot be reduced indefinitely because roundoff eventually dominates."
 C7 = "Newton's method depends on derivative behaviour and initialisation."
 C8 = "Iterative solver stopping criteria must account for scaling and conditioning."
 C9 = "Adaptive refinement requires a trustworthy error indicator or estimator."
 C10 = "Numerical accuracy claims must include enough precision and method context to be interpretable."
}

SEMANTIC_EQUIVALENCE {
 "NumericalAnalysis" <=> "MathematicsOfNumericalApproximation"
 "NumericalMethod" <=> "AlgorithmicApproximationMethod"
 "Conditioning" <=> "ProblemSensitivityToInputPerturbation"
 "Stability" <=> "AlgorithmSensitivityToComputationalPerturbation"
 "Convergence" <=> "ApproximationApproachesExactSolution"
 "OrderOfAccuracy" <=> "AsymptoticErrorDecayRate"
}

VALIDATION {
 V1 = "Numerical problem class is identified."
 V2 = "Method assumptions are satisfied."
 V3 = "Error metric is appropriate."
 V4 = "Conditioning is considered."
 V5 = "Stability is considered."
 V6 = "Convergence evidence is available when claimed."
 V7 = "Solver tolerances are explicit."
 V8 = "Finite-precision effects are considered where material."
 V9 = "Reference or benchmark evidence is appropriate."
 V10 = "Computational cost is consistent with the requested accuracy."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_ANALYSIS_DEFINITION = 0.99
 METHOD_SELECTION_REASONING = 0.98
 ERROR_ANALYSIS_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 STABILITY_REASONING = 0.98
 CONVERGENCE_REASONING = 0.99
 ROOT_FINDING_REASONING = 0.99
 LINEAR_SYSTEM_REASONING = 0.98

 POLICY =
  "Reduce confidence when method assumptions, conditioning, convergence evidence, tolerances, discretisation scale, floating-point precision or reference solution are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalAnalysisReasoning,
  NumericalMethodSelection,
  ErrorAnalysis,
  ConditioningAnalysis,
  StabilityAnalysis,
  ConvergenceAnalysis,
  RootFindingReasoning,
  NumericalLinearAlgebraReasoning,
  InterpolationReasoning,
  QuadratureReasoning,
  NumericalDifferentiationReasoning,
  DifferentialEquationSolverReasoning,
  AdaptiveMethodReasoning,
  ScientificComputingReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "numerical analysis" -> NumericalAnalysis
  "numerical method" -> NumericalMethod
  "conditioning" -> Conditioning
  "condition number" -> ConditionNumber
  "stability" -> Stability WHEN numerical_context
  "consistency" -> Consistency WHEN numerical_context
  "convergence" -> Convergence WHEN numerical_context
  "order of accuracy" -> OrderOfAccuracy
  "root finding" -> RootFinding
  "quadrature" -> NumericalIntegration
  "numerical differentiation" -> NumericalDifferentiation
 }

 INTERPRETATION_ORDER = [
  detect_numerical_analysis_context,
  identify mathematical_problem_structure_dimension_smoothness_conditioning_and_target_accuracy,
  classify root_linear_system_interpolation_integration_differentiation_ODE_PDE_eigenvalue_or_optimisation problem,
  select compatible_numerical method,
  compute approximation,
  analyse error_conditioning_stability_convergence_and_cost,
  verify against residual_reference_or_refinement evidence,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("numerical analysis")
  OR numerical_approximation_error_convergence_context
  THEN activate(NumericalAnalysis)

 E2:
  IF root_finding_problem
  THEN identify bracketing_derivative_and_initialisation information

 E3:
  IF linear_system_problem
  THEN inspect matrix_structure_conditioning_and_sparsity before solver selection

 E4:
  IF convergence_claim
  THEN require systematic iteration_or_refinement evidence

 E5:
  IF finite_difference_context
  THEN balance truncation_and_roundoff error

 E6:
  IF iterative_solver
  THEN define residual_norm_and_stopping criterion

 E7:
  IF adaptive_method
  THEN require error_estimator_and_tolerance

 E8:
  IF ill_conditioned_problem
  THEN distinguish unavoidable sensitivity_from_algorithmic instability

 E9:
  IF high_accuracy_requested
  THEN consider precision_limits_and_computational cost
}

RECURSION {
 ENTRY = NumericalAnalysis

 EXPAND(NumericalAnalysis) -> [
  NumericalMethod,
  Approximation,
  Discretisation,
  FloatingPointArithmetic,
  RoundoffError,
  TruncationError,
  ErrorBound,
  Conditioning,
  ConditionNumber,
  Stability,
  Consistency,
  Convergence,
  OrderOfAccuracy,
  RootFinding,
  NumericalLinearAlgebra,
  Interpolation,
  ApproximationTheory,
  NumericalDifferentiation,
  NumericalIntegration,
  OrdinaryDifferentialEquationSolver,
  PartialDifferentialEquationSolver,
  NumericalOptimisation,
  AdaptiveMethod,
  ScientificComputing
 ]

 EXPAND(RootFinding) -> [
  BisectionMethod,
  NewtonMethod,
  SecantMethod,
  FixedPointIteration,
  HybridMethod
 ]

 EXPAND(NumericalLinearAlgebra) -> [
  DirectMethod,
  IterativeMethod,
  MatrixFactorisation,
  Conditioning,
  Preconditioning,
  EigenvalueComputation
 ]

 EXPAND(DifferentialEquationMethods) -> [
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod,
  TimeIntegrationMethod,
  AdaptiveTimeStepping
 ]

 STOP_CONDITION =
  "Stop when the numerical problem, method, approximation, error, conditioning, stability, convergence, tolerance and computational-cost interpretation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Applied Mathematics Ontologies"

 IMMEDIATE_CONTEXTS = [
  "Applied Mathematics Ontologies",
  "Mathematical Modelling",
  "Computational Model Ontology",
  "Scientific Computing Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "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",
  "Approximation Theory Ontologies",
  "Computational Mathematics Ontologies"
 ]

 ROUTE_RULES = [
  "Numerical Analysis -> Applied Mathematics Ontologies for parent semantics",
  "Numerical Analysis -> Mathematical Modelling for model-solution context",
  "Numerical Analysis -> Computational Model Ontology for executable numerical representations",
  "Numerical Analysis -> Model Verification for convergence and solution-error assessment",
  "Numerical Analysis -> Scientific Computing for large-scale computation",
  "Numerical Analysis -> Linear Algebra for matrix problems",
  "Numerical Analysis -> Calculus & Analysis for approximation of derivatives and integrals",
  "Numerical Analysis -> Differential Equations for ODE and PDE solvers",
  "Numerical Analysis -> Optimisation for numerical minimisation and maximisation",
  "Numerical Analysis -> Computational Mathematics for algorithmic implementation"
 ]
}

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 approximation semantics.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve consistency-versus-convergence distinction.",
  "Preserve forward-versus-backward error distinction.",
  "Preserve finite-precision semantics.",
  "Preserve refinement-based convergence reasoning.",
  "Preserve error-and-cost tradeoff.",
  "Preserve machine-readable numerical-analysis semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Numerical analysis studies algorithms for approximating mathematical solutions and the error, stability, conditioning and convergence of those algorithms."

 ERROR_SUMMARY =
  "Numerical error may arise from discretisation, truncation, iteration, data perturbation and floating-point arithmetic."

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

 STABILITY_SUMMARY =
  "Stability describes sensitivity of the numerical algorithm to computational perturbations."

 CONVERGENCE_SUMMARY =
  "A convergent numerical method approaches the intended solution under valid refinement or iteration."

 ROOT_FINDING_SUMMARY =
  "Root-finding methods approximate solutions of nonlinear equations."

 LINEAR_ALGEBRA_SUMMARY =
  "Numerical linear algebra provides stable algorithms for linear systems, factorisations and eigenvalue problems."

 DIFFERENTIAL_EQUATION_SUMMARY =
  "ODE and PDE solvers approximate continuous dynamics through discrete computational methods."

 VERIFICATION_SUMMARY =
  "Numerical results should be supported by residual, benchmark, error-estimation or refinement evidence."
}

FLOW {
 INPUT
 -> detect_numerical_analysis_context
 -> identify mathematical_problem_structure_dimension_smoothness_conditioning_precision_and_accuracy requirements
 -> classify root_linear_system_eigenvalue_interpolation_quadrature_differentiation_ODE_PDE_or_optimisation problem
 -> select compatible numerical_method
 -> construct discretisation_or_iteration
 -> compute approximation
 -> analyse truncation_roundoff_iteration_error_conditioning_stability_convergence_and_cost
 -> verify using residual_reference_benchmark_or_refinement evidence
 -> route to applied_mathematics mathematical_modelling 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 layer defines the mathematics of computational approximation. It supports floating-point arithmetic, error analysis, conditioning, stability, consistency, convergence, order of accuracy, root finding, numerical linear algebra, interpolation, approximation, numerical differentiation, quadrature, ODE and PDE solvers, optimisation, adaptive methods and verification of numerical reliability."
}

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

}

END_FLOW