Numerical Stability Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Stability Ontology 2 within the Kireth Research Semantic Library. Numerical stability studies how numerical algorithms respond to perturbations, finite-precision arithmetic, rounding, cancellation and accumulated computational error. This ontology supports forward and backward stability, absolute and relative stability, conditioning relationships, perturbation growth, stability regions, matrix algorithm stability, iterative method stability, time-stepping stability, floating-point effects and validation of reliable numerical computation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalStability
 ENTITY_CLASS = PerturbationResponseAlgorithmFramework
 PRIMARY_CONTEXT = NumericalMethods
 DEFINITION = "Numerical stability is the property describing how computational errors, perturbations and finite-precision effects influence the output of a numerical algorithm."
 SYMBOLIC_FORMS = [
  "computed_output=exact_output_for_nearby_input",
  "||delta y|| <= C ||delta x||",
  "R(z) bounded in stability_region",
  "forward_error <= conditioning * backward_error"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for algorithmic sensitivity, backward and forward stability, perturbation amplification, floating-point effects, cancellation, time-stepping stability and stable numerical design."
}

SCOPE {
 INCLUDE = [
  NumericalStability,
  Stability,
  AlgorithmicStability,
  ForwardStability,
  BackwardStability,
  AbsoluteStability,
  RelativeStability,
  ZeroStability,
  StrongStability,
  WeakStability,
  StabilityRegion,
  RegionOfAbsoluteStability,
  AStability,
  LStability,
  BStability,
  AlgebraicStability,
  ConditionalStability,
  UnconditionalStability,
  Perturbation,
  InputPerturbation,
  OutputPerturbation,
  ErrorAmplification,
  ErrorPropagation,
  FloatingPointArithmetic,
  MachinePrecision,
  MachineEpsilon,
  RoundoffError,
  AccumulatedRoundoff,
  Cancellation,
  CatastrophicCancellation,
  LossOfSignificance,
  Scaling,
  Rescaling,
  Normalisation,
  Conditioning,
  ConditionNumber,
  Sensitivity,
  ForwardError,
  BackwardError,
  Residual,
  RelativeError,
  AbsoluteError,
  StableAlgorithm,
  UnstableAlgorithm,
  WellConditionedProblem,
  IllConditionedProblem,
  MatrixStability,
  GaussianElimination,
  Pivoting,
  PartialPivoting,
  CompletePivoting,
  GrowthFactor,
  LUDecomposition,
  QRDecomposition,
  CholeskyDecomposition,
  OrthogonalTransformation,
  HouseholderTransformation,
  GivensRotation,
  EigenvalueStability,
  Pseudospectrum,
  NonNormalMatrix,
  IterativeMethod,
  FixedPointIteration,
  ContractionMapping,
  SpectralRadius,
  IterationMatrix,
  LinearStabilityAnalysis,
  NonlinearStabilityAnalysis,
  NumericalODE,
  ExplicitMethod,
  ImplicitMethod,
  EulerMethod,
  BackwardEulerMethod,
  RungeKuttaMethod,
  MultistepMethod,
  StiffEquation,
  CFLCondition,
  CourantNumber,
  VonNeumannStabilityAnalysis,
  NumericalPDE,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  EnergyStability,
  Monotonicity,
  PositivityPreservation,
  Boundedness,
  StabilityProof,
  StabilityEstimate,
  Robustness,
  Verification,
  Benchmarking,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  ProblemConditioningWithoutAlgorithmBehaviour,
  ConvergenceWithoutPerturbationOrStabilityContext,
  PhysicalSystemStabilityWithoutNumericalMethod,
  SoftwareReliabilityWithoutNumericalSemantics
 ]
 DISAMBIGUATION_RULE = "When the central question is whether numerical perturbations or finite-precision errors are amplified, controlled or damped by an algorithm, interpret the context as numerical stability."
}

CORE_CONCEPTS {
 NumericalStability = "Resistance of a numerical algorithm to harmful amplification of perturbations and finite-precision errors."
 BackwardStability = "Property that a computed result is the exact result for a nearby input problem."
 ForwardStability = "Property that the computed result remains close to the exact solution of the original problem."
 StabilityRegion = "Set of parameter values for which a numerical time-stepping method behaves stably."
 ErrorAmplification = "Growth of perturbations as they propagate through computation."
 Cancellation = "Subtraction of nearly equal quantities causing loss of significant digits."
 Conditioning = "Sensitivity of the mathematical problem itself to perturbations."
 GrowthFactor = "Measure of element growth during elimination and a contributor to numerical stability."
 Pseudospectrum = "Spectrum-like set describing sensitivity of eigenvalues and non-normal operator behaviour."
}

RELATIONS {
 NumericalStability --is_child_of--> NumericalMethods
 NumericalStability --analyses--> NumericalAlgorithm
 BackwardStability --relates_to--> NearbyProblem
 ForwardStability --relates_to--> ExactOriginalSolution
 Conditioning --describes--> ProblemSensitivity
 NumericalStability --describes--> AlgorithmSensitivity
 ForwardError --depends_on--> BackwardError
 ForwardError --depends_on--> Conditioning
 FloatingPointArithmetic --introduces--> RoundoffError
 Cancellation --causes--> LossOfSignificance
 Scaling --can_improve--> NumericalBehaviour
 Pivoting --improves--> GaussianEliminationStability
 OrthogonalTransformation --supports--> StableMatrixAlgorithms
 SpectralRadius --influences--> IterativeMethodStability
 StabilityRegion --characterises--> TimeSteppingMethod
 AStability --is_property_of--> ImplicitTimeIntegrator
 LStability --strengthens--> AStability
 CFLCondition --constrains--> ExplicitPDETimeStepping
 VonNeumannStabilityAnalysis --analyses--> LinearFiniteDifferenceScheme
 EnergyStability --bounds--> DiscreteEnergyGrowth
}

OPERATORS {
 FORWARD_ERROR(y_hat,y) := ||y_hat-y||
 BACKWARD_ERROR(x_hat,problem) := minimum_perturbation_making_x_hat_exact
 CONDITION_RELATION(kappa,eta) := relative_forward_error approximately kappa*relative_backward_error
 ERROR_AMPLIFICATION(e_in,e_out) := amplification=||e_out||/||e_in||
 FIXED_POINT_STABILITY(G) := spectral_radius(G)<1
 STABILITY_FUNCTION(R,z) := numerical_amplification=R(z)
 ABSOLUTE_STABILITY(R,z) := |R(z)|<=1
 EULER_STABILITY(z) := |1+z|<=1
 BACKWARD_EULER_STABILITY(z) := |1/(1-z)|<=1
 CFL_NUMBER(a,dt,dx) := nu=a*dt/dx
 GROWTH_FACTOR(U,A) := rho=max_ij|U_ij|/max_ij|A_ij|
}

AXIOMS {
 A1 = "Numerical stability is a property of an algorithm under a specified perturbation and arithmetic model."
 A2 = "Problem conditioning and algorithm stability are distinct."
 A3 = "Backward stability often provides a strong interpretation of numerical reliability."
 A4 = "Forward accuracy depends jointly on backward error and conditioning."
 A5 = "Finite-precision arithmetic can destabilise algorithms that are stable in exact arithmetic."
 A6 = "Time-stepping stability depends on method, step size and problem spectrum."
 A7 = "Non-normal operators can exhibit large transient growth despite stable eigenvalues."
 A8 = "Stability claims require explicit norms, perturbation models and validation regimes."
}

REASONING {
 R1_CONTEXT = identify(problem,algorithm,precision,norm,perturbation_model)
 R2_CONDITIONING = analyse(problem_sensitivity)
 R3_BACKWARD = determine_if_computed_result_solves_nearby_problem)
 R4_FORWARD = estimate_forward_error_from_backward_error_and_conditioning)
 R5_FLOATING_POINT = analyse(roundoff,cancellation,scaling_and_growth)
 R6_MATRIX = if_matrix_algorithm analyse(pivoting,orthogonality,growth_factor,pseudospectrum)
 R7_ITERATIVE = if_iterative analyse(spectral_radius,contraction_and_error_propagation)
 R8_TIME_STEPPING = if_ODE_or_PDE analyse(stability_function,stability_region,CFL_or_energy_bounds)
 R9_REFORMULATION = if_unstable choose_scaling,pivoting,orthogonalisation,implicit_method_or_alternative_algorithm)
 R10_VALIDATION = compare_theory,perturbation_tests,precision_sweeps,reference_solutions_and_reproducibility)
}

CONSTRAINTS {
 C1 = "A backward-stable algorithm can still have large forward error on an ill-conditioned problem."
 C2 = "Small eigenvalue magnitudes alone do not guarantee transient stability for non-normal systems."
 C3 = "Reducing a timestep may improve stability but can increase computational cost and roundoff accumulation."
 C4 = "Explicit methods can be conditionally stable."
 C5 = "A-stability does not imply strong damping of stiff modes; L-stability addresses stronger decay."
 C6 = "Cancellation can destroy significant digits even when individual operations are correctly rounded."
 C7 = "Pivoting strategies improve but do not absolutely guarantee small growth in every case."
 C8 = "Scaling can improve numerical behaviour without changing the exact mathematical problem."
 C9 = "Stability in one norm does not imply stability in every norm."
 C10 = "Empirical stability over a few examples does not constitute a general stability proof."
}

SEMANTIC_EQUIVALENCE {
 "NumericalStability" <=> "AlgorithmicNumericalStability"
 "BackwardStability" <=> "BackwardStableComputation"
 "RegionOfAbsoluteStability" <=> "StabilityRegion"
 "CatastrophicCancellation" <=> "SevereCancellation"
 "AStability" <=> "A-Stability"
 "LStability" <=> "L-Stability"
}

VALIDATION {
 V1 = "Algorithm, arithmetic model and perturbation norm are explicit."
 V2 = "Conditioning is analysed separately from stability."
 V3 = "Backward or forward error is reported with appropriate interpretation."
 V4 = "Floating-point effects are considered."
 V5 = "Matrix algorithms assess pivoting, growth or orthogonality where relevant."
 V6 = "Iterative methods assess spectral or contraction properties."
 V7 = "Time-stepping methods identify their stability region."
 V8 = "PDE methods assess CFL, energy or equivalent stability conditions."
 V9 = "Precision or perturbation sweeps are used where feasible."
 V10 = "Stability claims are reproducible under documented settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_STABILITY_DEFINITION = 0.99
 BACKWARD_STABILITY_REASONING = 0.99
 FORWARD_STABILITY_REASONING = 0.99
 FLOATING_POINT_STABILITY_REASONING = 0.99
 MATRIX_STABILITY_REASONING = 0.98
 ITERATIVE_STABILITY_REASONING = 0.99
 ODE_STABILITY_REASONING = 0.99
 PDE_STABILITY_REASONING = 0.98
 POLICY = "Reduce confidence when norm, perturbation model, arithmetic precision, conditioning, timestep, spectrum, pivoting or stability criterion are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalStabilityReasoning,
  BackwardStabilityReasoning,
  ForwardStabilityReasoning,
  ErrorAmplificationReasoning,
  FloatingPointReasoning,
  CancellationReasoning,
  ConditioningRelationshipReasoning,
  MatrixStabilityReasoning,
  PivotingReasoning,
  IterativeMethodStabilityReasoning,
  SpectralRadiusReasoning,
  ODEStabilityReasoning,
  StabilityRegionReasoning,
  AStabilityReasoning,
  LStabilityReasoning,
  PDEStabilityReasoning,
  CFLReasoning,
  VonNeumannStabilityReasoning,
  EnergyStabilityReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]
 NORMALISE {
  "numerical stability" -> NumericalStability
  "backward stable" -> BackwardStability
  "forward stable" -> ForwardStability
  "stability region" -> StabilityRegion
  "A-stability" -> AStability
  "L-stability" -> LStability
  "CFL condition" -> CFLCondition
  "catastrophic cancellation" -> CatastrophicCancellation
 }
}

EXECUTION_RULES {
 E1 = "If numerical perturbation amplification is central, activate NumericalStabilityOntology."
 E2 = "If a computed result can be interpreted as exact for a nearby problem, use backward-stability reasoning."
 E3 = "If output accuracy relative to the original problem is central, combine stability with conditioning."
 E4 = "If floating-point cancellation is present, reformulate or rescale when possible."
 E5 = "If Gaussian elimination is used, assess pivoting and element growth."
 E6 = "If an iterative method is used, analyse the iteration matrix or contraction factor."
 E7 = "If solving ODEs, analyse the stability function and problem eigenvalues."
 E8 = "If solving PDEs explicitly, assess CFL or equivalent stability restrictions."
 E9 = "Any stability claim should be validated with perturbation analysis, precision tests and appropriate theoretical criteria."
}

RECURSION {
 ENTRY = NumericalStability
 EXPAND(NumericalStability) -> [
  Stability, AlgorithmicStability, ForwardStability, BackwardStability,
  AbsoluteStability, RelativeStability, ZeroStability, StrongStability,
  WeakStability, StabilityRegion, RegionOfAbsoluteStability, AStability,
  LStability, BStability, AlgebraicStability, ConditionalStability,
  UnconditionalStability, Perturbation, InputPerturbation,
  OutputPerturbation, ErrorAmplification, ErrorPropagation,
  FloatingPointArithmetic, MachinePrecision, MachineEpsilon,
  RoundoffError, AccumulatedRoundoff, Cancellation,
  CatastrophicCancellation, LossOfSignificance, Scaling, Rescaling,
  Normalisation, Conditioning, ConditionNumber, Sensitivity,
  ForwardError, BackwardError, Residual, RelativeError, AbsoluteError,
  StableAlgorithm, UnstableAlgorithm, WellConditionedProblem,
  IllConditionedProblem, MatrixStability, GaussianElimination, Pivoting,
  PartialPivoting, CompletePivoting, GrowthFactor, LUDecomposition,
  QRDecomposition, CholeskyDecomposition, OrthogonalTransformation,
  HouseholderTransformation, GivensRotation, EigenvalueStability,
  Pseudospectrum, NonNormalMatrix, IterativeMethod, FixedPointIteration,
  ContractionMapping, SpectralRadius, IterationMatrix,
  LinearStabilityAnalysis, NonlinearStabilityAnalysis, NumericalODE,
  ExplicitMethod, ImplicitMethod, EulerMethod, BackwardEulerMethod,
  RungeKuttaMethod, MultistepMethod, StiffEquation, CFLCondition,
  CourantNumber, VonNeumannStabilityAnalysis, NumericalPDE,
  FiniteDifferenceMethod, FiniteElementMethod, FiniteVolumeMethod,
  EnergyStability, Monotonicity, PositivityPreservation, Boundedness,
  StabilityProof, StabilityEstimate, Robustness, Verification,
  Benchmarking, Reproducibility
 ]
 EXPAND(StabilityFamilies) -> [
  ForwardAndBackwardStability,
  FloatingPointStability,
  MatrixAlgorithmStability,
  IterativeMethodStability,
  ODEStability,
  PDEStability,
  SpectralAndNonNormalStability
 ]
 STOP_CONDITION = "Stop when perturbation model, conditioning, algorithm sensitivity, arithmetic effects, stability criterion and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Methods"
 RELATED_ONTOLOGIES = [
  "Numerical Methods",
  "Numerical Methods Ontology 2",
  "Numerical Analysis Ontology 2",
  "Numerical Approximation Ontology",
  "Numerical Computation Ontology",
  "Floating Point Arithmetic Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Differential Equation Ontologies",
  "Scientific Computing Ontology 2"
 ]
 ROUTE_RULES = [
  "Numerical Stability -> Numerical Methods for parent semantics",
  "Numerical Stability -> Numerical Methods Ontology 2 for core method structure",
  "Numerical Stability -> Numerical Analysis for formal error and conditioning relationships",
  "Numerical Stability -> Numerical Approximation for stable approximation schemes",
  "Numerical Stability -> Numerical Computation for finite-precision semantics",
  "Numerical Stability -> Floating Point Arithmetic for rounding and cancellation",
  "Numerical Stability -> Numerical Linear Algebra for matrix algorithm stability",
  "Numerical Stability -> Differential Equations for time-stepping and PDE stability",
  "Numerical Stability -> Scientific Computing for applied simulation stability"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible stability concepts, methods or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve conditioning-versus-stability distinction.",
  "Preserve forward-versus-backward stability distinction.",
  "Preserve exact-arithmetic-versus-floating-point distinction.",
  "Preserve stable-versus-unstable algorithm distinction.",
  "Preserve conditional-versus-unconditional stability distinction.",
  "Preserve matrix-versus-time-stepping stability distinction.",
  "Preserve norm-dependent stability semantics.",
  "Preserve machine-readable numerical-stability semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Numerical stability describes how perturbations and finite-precision errors affect the outputs of numerical algorithms."
 BACKWARD_SUMMARY = "Backward stability interprets a computed result as the exact solution of a nearby problem."
 FORWARD_SUMMARY = "Forward stability measures closeness of the computed result to the exact solution of the original problem."
 CONDITIONING_SUMMARY = "Forward accuracy depends jointly on algorithmic stability and problem conditioning."
 FLOATING_POINT_SUMMARY = "Rounding, cancellation, scaling and element growth influence numerical stability under finite precision."
 MATRIX_SUMMARY = "Pivoting, orthogonal transformations and growth control support stable matrix computations."
 TIME_STEPPING_SUMMARY = "ODE and PDE methods require stability regions, CFL conditions or energy estimates appropriate to the problem."
 VALIDATION_SUMMARY = "Stability claims should be checked against perturbation theory, precision tests, spectra, timestep restrictions and reproducible numerical experiments."
}

FLOW {
 INPUT
 -> detect_numerical_stability_context
 -> identify_problem_algorithm_precision_norm_and_perturbation_model
 -> analyse_problem_conditioning
 -> determine_backward_and_or_forward_stability
 -> analyse_roundoff_cancellation_scaling_and_error_amplification
 -> if_matrix_algorithm_assess_pivoting_growth_orthogonality_and_pseudospectral_sensitivity
 -> if_iterative_assess_iteration_matrix_spectral_radius_or_contraction
 -> if_ODE_assess_stability_function_region_and_stiffness
 -> if_PDE_assess_CFL_Von_Neumann_energy_or_monotonicity_conditions
 -> reformulate_scale_pivot_precondition_or_choose_alternative_method_if_required
 -> validate_with_precision_sweeps_perturbation_tests_reference_solutions_and_theoretical_bounds
 -> route_to_numerical_methods_core_numerical_methods_numerical_analysis_numerical_approximation_numerical_computation_floating_point_linear_algebra_differential_equations_or_scientific_computing_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Stability Ontology 2 defines algorithmic resistance to perturbations and finite-precision error. It supports forward and backward stability, absolute, relative, zero, A-, L-, B- and algebraic stability, conditional and unconditional stability, perturbation and error amplification, floating-point arithmetic, roundoff, cancellation and loss of significance, scaling and normalisation, conditioning and condition numbers, forward and backward error, stable and unstable algorithms, Gaussian elimination, pivoting and growth factors, LU, QR and Cholesky stability, orthogonal transformations, eigenvalue sensitivity and pseudospectra, iterative-method spectral-radius analysis, contraction mappings, ODE stability functions and regions, stiff equations, CFL conditions, Von Neumann analysis, PDE energy stability, monotonicity, positivity preservation, boundedness, stability proofs, verification, benchmarking and reproducibility."
}

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

}

END_FLOW