Numerical Stability Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Stability Ontology within the Kireth Research Semantic Library. Numerical stability concerns how numerical algorithms respond to perturbations introduced by finite precision, discretisation, data error, iterative approximation and computational transformations. This ontology supports forward and backward stability, absolute and relative stability, perturbation growth, amplification factors, stability regions, A-stability, L-stability, zero-stability, von Neumann stability, condition-aware interpretation, roundoff propagation, cancellation, scaling, rescaling, preconditioning, stable factorisation and relationships with numerical analysis, iterative methods, finite differences, ODE solvers, linear algebra and scientific computing.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalStability
 SYMBOLIC_FORMS = [
  "delta_out <= C delta_in",
  "|G(k)| <= 1",
  "R(z)",
  "backward error"
 ]
 ENTITY_CLASS = AlgorithmPerturbationControlFramework
 PRIMARY_CONTEXT = NumericalAnalysis
 DEFINITION = "Numerical stability is the property describing whether a numerical method controls the amplification of perturbations introduced by data errors, finite precision, discretisation or intermediate computation."
 SEMANTIC_ROLE = "Provides the machine-readable framework for stability classification, perturbation propagation, amplification factors, backward error, absolute-stability regions, zero-stability, von Neumann analysis, roundoff control and condition-aware interpretation."
}

SCOPE {
 INCLUDE = [
  NumericalStability,
  StableAlgorithm,
  UnstableAlgorithm,
  ForwardStability,
  BackwardStability,
  MixedStability,
  AbsoluteStability,
  RelativeStability,
  StabilityRegion,
  StabilityFunction,
  AmplificationFactor,
  Perturbation,
  ErrorPropagation,
  RoundoffError,
  FloatingPointError,
  Cancellation,
  CatastrophicCancellation,
  Overflow,
  Underflow,
  Scaling,
  Rescaling,
  Conditioning,
  ConditionNumber,
  ZeroStability,
  AStability,
  LStability,
  BStability,
  AlgebraicStability,
  VonNeumannStability,
  EnergyStability,
  Contractivity,
  TimeStepRestriction,
  CFLCondition,
  StableFactorisation,
  Pivoting,
  Preconditioning,
  ErrorGrowth,
  ErrorDamping
 ]

 EXCLUDE_AS_PRIMARY = [
  MathematicalProblemConditioningWithoutAlgorithmContext,
  ModelValidation,
  PhysicalStabilityWithoutNumericalAlgorithmMeaning,
  DynamicalSystemStabilityUnlessNumericalMethodContext
 ]

 DISAMBIGUATION_RULE =
  "When the question concerns how a numerical algorithm amplifies or controls perturbations, roundoff or discretisation errors, interpret the context as numerical stability."
}

CORE_CONCEPTS {

 NumericalStability {
  definition = "The controlled response of a numerical algorithm to perturbations arising during computation."
 }

 ForwardStability {
  definition = "A stability notion comparing the computed result directly with the exact result."
 }

 BackwardStability {
  definition = "A stability notion in which the computed result is the exact solution of a nearby perturbed problem."
 }

 StabilityRegion {
  definition = "The set of scaled problem parameters for which a numerical time-integration method remains stable."
 }

 StabilityFunction {
  symbol = "R(z)"
  definition = "The response of a numerical time-stepping method to the linear test equation y'=lambda y."
 }

 AmplificationFactor {
  definition = "A factor describing growth or decay of a numerical error or Fourier mode across computational steps."
 }

 ZeroStability {
  definition = "The property that perturbations in starting values of a multistep method remain controlled under refinement."
 }

 AStability {
  definition = "The property that the entire left half of the complex plane lies within a method's absolute stability region."
 }

 LStability {
  definition = "A-stability plus strong damping of highly stiff modes as z tends to negative infinity."
 }

 VonNeumannStability {
  definition = "Stability assessment of a linear difference scheme using Fourier-mode amplification."
 }

 Cancellation {
  definition = "Loss of significant digits caused by subtracting nearly equal floating-point quantities."
 }

 Scaling {
  definition = "Transformation of variables, equations or data magnitudes to improve numerical behaviour."
 }
}

RELATIONS {
 NumericalStability --is_property_of--> NumericalMethod
 NumericalStability --is_distinct_from--> Conditioning
 ForwardStability --is_type_of--> NumericalStability
 BackwardStability --is_type_of--> NumericalStability
 StabilityFunction --defines--> StabilityRegion
 AmplificationFactor --measures--> PerturbationGrowth
 RoundoffError --may_be_amplified_by--> UnstableAlgorithm
 Cancellation --increases--> RelativeError
 Scaling --may_improve--> NumericalStability
 Pivoting --improves--> FactorisationStability
 Preconditioning --may_improve--> IterativeStabilityAndConvergence
 ZeroStability --is_required_for--> MultistepConvergence
 AStability --is_property_of--> TimeIntegrationMethod
 LStability --is_stronger_than--> AStability
 VonNeumannStability --analyses--> FiniteDifferenceScheme
 CFLCondition --may_constrain--> StableTimeStep
}

OPERATORS {
 FORWARD_ERROR(exact,computed) :=
  norm(computed-exact)

 BACKWARD_ERROR(problem,computed) :=
  smallest_problem_perturbation_for_which_computed_is_exact_solution

 RELATIVE_FORWARD_ERROR(exact,computed) :=
  norm(computed-exact)/norm(exact)
  WHEN norm(exact)!=0

 STABILITY_FUNCTION(method,z) :=
  R_method(z)

 ABSOLUTE_STABILITY_TEST(R,z) :=
  abs(R(z))<=1

 AMPLIFICATION_TEST(G,k) :=
  abs(G(k))<=1
  under selected Fourier-mode assumptions

 ZERO_STABILITY_TEST(characteristic_polynomial) :=
  root_condition:
   all_roots_abs<=1
   AND roots_on_unit_circle_are_simple

 ROUNDING_MODEL(x_op_y) :=
  fl(x_op_y)=(x_op_y)*(1+delta)
  with abs(delta)<=u
  under standard floating_point model

 CONDITION_AWARE_ERROR_BOUND(kappa,backward_error) :=
  forward_error approximately bounded_by kappa*backward_error
  under local assumptions

 SCALE_VARIABLE(x,s) :=
  x/s

 RESCALE_SYSTEM(A,b,D1,D2) :=
  D1*A*D2 and D1*b
}

DEFINITIONS {
 D1 = "Numerical stability concerns the algorithm, while conditioning concerns the underlying problem."
 D2 = "Backward stability is often a strong practical guarantee."
 D3 = "A backward-stable algorithm can still have large forward error on an ill-conditioned problem."
 D4 = "Absolute stability is central to time-integration methods."
 D5 = "A-stability is valuable for stiff differential equations."
 D6 = "L-stability adds damping of strongly stiff modes."
 D7 = "Zero-stability is necessary for convergence of consistent linear multistep methods."
 D8 = "Von Neumann stability studies Fourier-mode amplification in linear difference schemes."
 D9 = "Catastrophic cancellation can destroy relative precision."
 D10 = "Scaling and reformulation can materially improve numerical stability."
}

AXIOMS {
 A1_ALGORITHM_PROPERTY:
  NumericalStability is primarily a property of a numerical algorithm or discretisation

 A2_CONDITIONING_DISTINCTION:
  Stability and conditioning are distinct concepts

 A3_PERTURBATION:
  Stability analysis studies propagation of perturbations

 A4_BACKWARD_STABILITY:
  Backward-stable computation corresponds to exact solution of a nearby problem

 A5_STABILITY_REGION:
  Time-integration stability depends on the location of scaled eigenvalues relative to a stability region

 A6_ZERO_STABILITY:
  Consistent multistep convergence requires zero-stability

 A7_FINITE_PRECISION:
  Floating-point rounding can generate perturbations even when input data are exact

 A8_REFORMULATION:
  Algebraically equivalent formulas may have different numerical stability
}

REASONING {

 R1_STABILITY_CONTEXT {
  INPUT = numerical_algorithm
  IDENTIFY = linear_algebra_time_integration_finite_difference_iterative_or_general floating_point context
  RETURN = stability_class
 }

 R2_FORWARD_BACKWARD_ANALYSIS {
  INPUT = algorithm_problem_and_computed_solution
  COMPUTE = forward_error_when_reference_available
  ESTIMATE = backward_error
  COMPARE = against conditioning
  RETURN = stability_profile
 }

 R3_TIME_INTEGRATION_STABILITY {
  INPUT = method_and_test_equation
  DERIVE = stability_function_R(z)
  COMPUTE = stability_region
  CLASSIFY = A_stable_L_stable_or_conditionally stable
  RETURN = time_method_stability
 }

 R4_ZERO_STABILITY {
  INPUT = multistep_characteristic_polynomial
  COMPUTE = roots
  APPLY = root_condition
  RETURN = zero_stable_or_not
 }

 R5_VON_NEUMANN {
  INPUT = linear_finite_difference_scheme
  SUBSTITUTE = Fourier_mode
  DERIVE = amplification_factor
  TEST = abs(G)<=1
  RETURN = mode_stability_condition
 }

 R6_ROUNDOFF_PROPAGATION {
  INPUT = floating_point_algorithm
  IDENTIFY = subtraction_division_scaling_and_repeated operation pathways
  ESTIMATE = perturbation amplification
  RETURN = roundoff_stability_profile
 }

 R7_CANCELLATION_ANALYSIS {
  INPUT = arithmetic_expression
  DETECT = subtraction_of_nearly_equal quantities
  ESTIMATE = significant_digit loss
  CONSIDER = algebraically_equivalent stable reformulation
  RETURN = cancellation_risk
 }

 R8_SCALING_ANALYSIS {
  INPUT = numerical_problem
  IDENTIFY = poorly_scaled variables_or_equations
  APPLY = scaling_or_nondimensionalisation
  REASSESS = conditioning_and_stability
  RETURN = scaled_problem
 }

 R9_FACTORISATION_STABILITY {
  INPUT = matrix_factorisation
  CHECK = pivot_growth_and_backward error
  APPLY = pivoting_when_needed
  RETURN = stable_factorisation profile
 }

 R10_STABILITY_VERIFICATION {
  INPUT = theoretical_and_computational evidence
  COMPARE = predicted_stability_with_refinement_or_perturbation behaviour
  RETURN = verified_stability_status
 }
}

CONSTRAINTS {
 C1 = "Numerical stability must not be conflated with mathematical problem conditioning."
 C2 = "Small backward error does not imply small forward error for ill-conditioned problems."
 C3 = "A-stability does not imply high accuracy."
 C4 = "L-stability is stronger than A-stability for stiff decay."
 C5 = "Von Neumann analysis has limited direct applicability to nonlinear or strongly variable-coefficient problems."
 C6 = "Cancellation risk depends on data scale and representation."
 C7 = "Scaling can improve numerical behaviour but changes variable magnitudes and interpretation."
 C8 = "Pivoting strategies can alter computational cost and sparsity."
 C9 = "Finite-precision stability depends on machine precision and operation ordering."
 C10 = "Empirical stability observations should not replace theoretical guarantees where such guarantees are required."
}

SEMANTIC_EQUIVALENCE {
 "NumericalStability" <=> "AlgorithmPerturbationControl"
 "BackwardStability" <=> "ExactSolutionOfNearbyProblemProperty"
 "ForwardStability" <=> "ComputedSolutionCloseToExactSolutionProperty"
 "StabilityRegion" <=> "SetOfStableScaledEigenvalues"
 "VonNeumannStability" <=> "FourierModeAmplificationStability"
 "ZeroStability" <=> "MultistepRootConditionStability"
}

VALIDATION {
 V1 = "Algorithm and problem are distinguished."
 V2 = "Conditioning is considered separately."
 V3 = "Perturbation model is identified."
 V4 = "Stability function or amplification factor is derived correctly where applicable."
 V5 = "Time-step restrictions are checked."
 V6 = "Zero-stability root condition is applied correctly."
 V7 = "Roundoff model matches finite precision."
 V8 = "Cancellation-prone formulas are identified."
 V9 = "Scaling and pivoting effects are documented."
 V10 = "Stability claims remain within the assumptions of the analysis."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_STABILITY_DEFINITION = 0.99
 FORWARD_BACKWARD_REASONING = 0.99
 TIME_INTEGRATION_STABILITY_REASONING = 0.99
 ZERO_STABILITY_REASONING = 0.99
 VON_NEUMANN_REASONING = 0.98
 ROUNDOFF_REASONING = 0.98
 CANCELLATION_REASONING = 0.99
 SCALING_REASONING = 0.98

 POLICY =
  "Reduce confidence when perturbation model, problem conditioning, step size, spectrum, floating-point precision, coefficient variation, nonlinear effects or stability assumptions are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalStabilityReasoning,
  ForwardStabilityReasoning,
  BackwardStabilityReasoning,
  StabilityRegionReasoning,
  AStabilityReasoning,
  LStabilityReasoning,
  ZeroStabilityReasoning,
  VonNeumannStabilityReasoning,
  RoundoffPropagation,
  CancellationDetection,
  ScalingReasoning,
  FactorisationStability,
  PreconditioningReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "numerical stability" -> NumericalStability
  "stable algorithm" -> StableAlgorithm
  "backward stable" -> BackwardStability
  "forward stable" -> ForwardStability
  "stability region" -> StabilityRegion
  "A-stability" -> AStability
  "L-stability" -> LStability
  "zero-stability" -> ZeroStability
  "von Neumann stability" -> VonNeumannStability
  "catastrophic cancellation" -> CatastrophicCancellation
 }

 INTERPRETATION_ORDER = [
  detect_numerical_stability_context,
  identify algorithm_problem_conditioning_precision_step_size_spectrum_and_perturbation model,
  classify forward_backward_absolute_zero_vonNeumann_energy_or_other stability type,
  derive relevant error_growth_stability_function_or_amplification relation,
  compare against stability criterion,
  inspect roundoff_cancellation_scaling_and_conditioning interactions,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("numerical stability")
  OR asks_if_algorithm_controls_perturbation growth
  THEN activate(NumericalStabilityOntology)

 E2:
  IF computed_solution_has_small_backward_error
  THEN inspect condition_number_before inferring small_forward error

 E3:
  IF time_integration_method
  THEN derive_or_use stability_function_and_region

 E4:
  IF stiff_ODE_context
  THEN assess A_stability_and_L_stability

 E5:
  IF linear_multistep_method
  THEN check zero_stability root condition

 E6:
  IF linear_finite_difference_scheme
  THEN consider von_Neumann amplification analysis

 E7:
  IF subtracting_nearly_equal quantities
  THEN flag cancellation_and_consider reformulation

 E8:
  IF poorly_scaled_system
  THEN consider scaling_or_preconditioning

 E9:
  IF factorisation_without_pivoting_on_general_matrix
  THEN assess pivot_growth_and_backward stability
}

RECURSION {
 ENTRY = NumericalStability

 EXPAND(NumericalStability) -> [
  StableAlgorithm,
  UnstableAlgorithm,
  ForwardStability,
  BackwardStability,
  MixedStability,
  AbsoluteStability,
  StabilityRegion,
  StabilityFunction,
  AmplificationFactor,
  Perturbation,
  ErrorPropagation,
  RoundoffError,
  FloatingPointError,
  Cancellation,
  CatastrophicCancellation,
  Scaling,
  Conditioning,
  ZeroStability,
  AStability,
  LStability,
  VonNeumannStability,
  EnergyStability,
  TimeStepRestriction,
  CFLCondition,
  StableFactorisation,
  Pivoting,
  Preconditioning
 ]

 EXPAND(TimeIntegrationStability) -> [
  StabilityFunction,
  StabilityRegion,
  AbsoluteStability,
  AStability,
  LStability,
  BStability,
  AlgebraicStability
 ]

 EXPAND(FinitePrecisionStability) -> [
  MachinePrecision,
  RoundoffError,
  Cancellation,
  Overflow,
  Underflow,
  Scaling,
  Pivoting
 ]

 EXPAND(PDEStability) -> [
  AmplificationFactor,
  VonNeumannStability,
  CFLCondition,
  EnergyStability,
  NumericalDamping
 ]

 STOP_CONDITION =
  "Stop when the numerical algorithm, perturbation model, conditioning, stability criterion, error-growth behaviour, finite-precision effects and final stability classification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Analysis"

 IMMEDIATE_CONTEXTS = [
  "Numerical Analysis Ontology",
  "Numerical Methods Ontology",
  "Iterative Methods Ontology",
  "Finite Difference Ontology"
 ]

 RELATED_ONTOLOGIES = [
  "Numerical Analysis Ontology",
  "Numerical Methods Ontology",
  "Iterative Methods Ontology",
  "Finite Difference Ontology",
  "Finite Element Ontology",
  "Spectral Method Ontology",
  "Root Finding Ontology",
  "Linear Algebra Ontologies",
  "Ordinary Differential Equations Ontologies",
  "Partial Differential Equations Ontologies",
  "Floating Point Arithmetic Ontologies",
  "Scientific Computing Ontologies",
  "Model Verification Ontology"
 ]

 ROUTE_RULES = [
  "Numerical Stability -> Numerical Analysis Ontology for parent numerical semantics",
  "Numerical Stability -> Numerical Methods Ontology for algorithm context",
  "Numerical Stability -> Iterative Methods for convergence and perturbation growth",
  "Numerical Stability -> Finite Difference for amplification and CFL analysis",
  "Numerical Stability -> Finite Element and Spectral Method for discretisation stability",
  "Numerical Stability -> Linear Algebra for factorisation and conditioning interactions",
  "Numerical Stability -> ODE Ontologies for A-stability, L-stability and zero-stability",
  "Numerical Stability -> Floating Point Arithmetic for roundoff and cancellation",
  "Numerical Stability -> Model Verification for empirical stability and refinement checks"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible stability notions, analysis methods or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve stability-versus-conditioning distinction.",
  "Preserve forward-versus-backward stability distinction.",
  "Preserve absolute-stability-region semantics.",
  "Preserve zero-stability root-condition semantics.",
  "Preserve von-Neumann amplification semantics.",
  "Preserve finite-precision perturbation semantics.",
  "Preserve cancellation and scaling awareness.",
  "Preserve machine-readable numerical-stability semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Numerical stability describes how strongly a numerical algorithm amplifies or controls perturbations introduced during computation."

 CONDITIONING_SUMMARY =
  "Conditioning belongs to the mathematical problem; stability belongs to the numerical algorithm."

 BACKWARD_SUMMARY =
  "A backward-stable algorithm returns the exact solution of a nearby perturbed problem."

 FORWARD_SUMMARY =
  "Forward error measures the distance between the computed and exact solution and depends on both stability and conditioning."

 TIME_INTEGRATION_SUMMARY =
  "Absolute stability regions determine which scaled eigenvalues are stably handled by a time-integration method."

 A_STABILITY_SUMMARY =
  "An A-stable method contains the full left half-plane in its absolute stability region."

 L_STABILITY_SUMMARY =
  "An L-stable method is A-stable and strongly damps highly stiff modes."

 ZERO_STABILITY_SUMMARY =
  "Zero-stability controls propagation of starting perturbations in linear multistep methods."

 FLOATING_POINT_SUMMARY =
  "Roundoff, cancellation, scaling and operation ordering influence finite-precision stability."
}

FLOW {
 INPUT
 -> detect_numerical_stability_context
 -> identify numerical_method_problem_conditioning_precision_discretisation_step_size_spectrum_and_perturbation sources
 -> classify forward_backward_absolute_zero_vonNeumann_energy_or_factorisation stability context
 -> derive forward_error_backward_error_stability_function_amplification_factor_or_root condition
 -> evaluate stability criterion
 -> inspect roundoff_cancellation_overflow_underflow_scaling_and_preconditioning
 -> compare stability behaviour with conditioning
 -> verify assumptions_and_empirical refinement evidence
 -> route to numerical_analysis_ontology numerical_methods iterative_methods finite_difference finite_element spectral_method root_finding linear_algebra ODE PDE floating_point scientific_computing_or_model_verification ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Stability Ontology defines how numerical algorithms respond to perturbations. It supports forward, backward and mixed stability, stability functions and regions, A- and L-stability, zero-stability, von Neumann and energy stability, amplification factors, CFL restrictions, finite-precision roundoff, cancellation, scaling, pivoting, preconditioning and condition-aware interpretation of numerical error."
}

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

}

END_FLOW