Ordinary Differential Equation Solver Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Ordinary Differential Equation Solver Ontology within the Kireth Research Semantic Library. An ordinary differential equation solver is a computational method for approximating solutions of ODE initial-value or boundary-value problems. This ontology supports explicit and implicit one-step methods, Runge-Kutta schemes, multistep methods, adaptive time stepping, stiff systems, event handling, dense output, nonlinear and linear subsolvers, stability, convergence, local and global error, invariant preservation and verification.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Ordinary Differential Equation Solver Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Differential Equation Solvers / Ordinary Differential Equation Solver"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/differential-equation-solvers/ordinary-differential-equation-solver-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = OrdinaryDifferentialEquationSolver
 ENTITY_CLASS = ComputationalODESolutionFramework
 PRIMARY_CONTEXT = DifferentialEquationSolver
 DEFINITION = "An ordinary differential equation solver is a numerical procedure that approximates solutions of one or more ordinary differential equations subject to specified initial or boundary conditions."
 SYMBOLIC_FORMS = [
  "y'(t)=f(t,y)",
  "y(t_0)=y_0",
  "y_(n+1)=Phi(t_n,y_n,h)",
  "F(t,y,y')=0"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for ODE initial-value and boundary-value solution, time integration, adaptive stepping, stiffness, error control, event handling, subsolver coupling and verification."
}

SCOPE {
 INCLUDE = [
  OrdinaryDifferentialEquationSolver, ODESolver,
  OrdinaryDifferentialEquation, ODE, ODESystem,
  InitialValueProblem, IVP, BoundaryValueProblem, BVP,
  FirstOrderODE, HigherOrderODE, AutonomousODE, NonautonomousODE,
  ExplicitODE, ImplicitODE, LinearODE, NonlinearODE,
  StiffODE, NonstiffODE, TimeIntegrator, TimeStepping,
  OneStepMethod, MultistepMethod, ExplicitMethod, ImplicitMethod,
  FixedStepMethod, AdaptiveStepMethod, StepSize, TimeStep,
  StepSizeController, ErrorEstimator, EmbeddedMethod,
  LocalTruncationError, GlobalError, ErrorControl,
  AbsoluteTolerance, RelativeTolerance, MixedTolerance,
  ForwardEuler, BackwardEuler, ImprovedEuler, HeunMethod,
  MidpointMethod, RungeKuttaMethod, RK2, RK3, RK4,
  EmbeddedRungeKutta, RungeKuttaFehlberg, RKF45,
  DormandPrince, CashKarp, BogackiShampine,
  AdamsBashforth, AdamsMoulton, PredictorCorrector,
  LinearMultistepMethod, BackwardDifferentiationFormula, BDF,
  GearMethod, ImplicitRungeKutta, DIRK, SDIRK,
  RadauMethod, GaussCollocation, RosenbrockMethod,
  ExponentialIntegrator, SymplecticIntegrator,
  VerletMethod, LeapfrogMethod, PartitionedIntegrator,
  Stiffness, StiffSolver, NonstiffSolver, StabilityRegion,
  AbsoluteStability, AStableMethod, LStableMethod,
  ZeroStability, Consistency, Convergence, OrderOfAccuracy,
  AdaptiveTimeStep, RejectedStep, AcceptedStep,
  DenseOutput, ContinuousExtension, Interpolation,
  EventDetection, EventLocation, EventFunction,
  RootFindingForEvents, Discontinuity, StateReset,
  Jacobian, MassMatrix, LinearSolver, NonlinearSolver,
  NewtonMethod, Preconditioner, KrylovMethod,
  Residual, Defect, ForwardError, BackwardError,
  PhaseError, DissipationError, LongTimeIntegration,
  Conservation, Invariant, EnergyPreservation,
  PositivityPreservation, Monotonicity, SolverConfiguration,
  SolverStatus, Success, Failure, Warning, MaximumSteps,
  FunctionEvaluationCount, JacobianEvaluationCount,
  FloatingPointArithmetic, MachinePrecision, RoundOffError,
  ComputationalComplexity, MemoryComplexity,
  ParallelODESolver, DistributedODESolver, GPUODESolver,
  Verification, ManufacturedSolution, ReferenceSolution,
  BenchmarkProblem, Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  PartialDifferentialEquationSolver,
  DifferentialAlgebraicEquationSolverWithoutODEReduction,
  SymbolicODESolutionWithoutNumericalIntegration,
  AlgebraicEquationSolverWithoutTimeEvolution
 ]
 DISAMBIGUATION_RULE = "When the task is to numerically approximate a time- or independent-variable-dependent solution of an ordinary differential equation or ODE system, interpret the context as an ordinary differential equation solver."
}

CORE_CONCEPTS {
 OrdinaryDifferentialEquationSolver = "Numerical method for approximating solutions of ordinary differential equations."
 InitialValueProblem = "ODE problem with solution data specified at an initial point."
 TimeIntegrator = "Numerical method advancing an ODE solution through the independent variable."
 AdaptiveStepMethod = "Method varying the step size according to an error estimate."
 StiffODE = "ODE whose numerical integration can impose severe stability restrictions on explicit methods."
 EmbeddedMethod = "Pair of related formulas of different orders used to estimate local error."
 DenseOutput = "Continuous or interpolated solution representation between accepted time steps."
 EventDetection = "Detection and location of states where a prescribed event function crosses a target value."
}

RELATIONS {
 OrdinaryDifferentialEquationSolver --is_child_of--> DifferentialEquationSolver
 OrdinaryDifferentialEquationSolver --solves--> OrdinaryDifferentialEquation
 InitialValueProblem --is_solved_by--> TimeIntegrator
 ExplicitMethod --advances_without--> NonlinearSolve
 ImplicitMethod --often_requires--> NonlinearSolver
 NonlinearSolver --often_uses--> LinearSolver
 EmbeddedRungeKutta --provides--> LocalErrorEstimate
 AdaptiveStepMethod --uses--> StepSizeController
 StiffODE --favours--> StiffSolver
 BackwardDifferentiationFormula --is_type_of--> ImplicitMultistepMethod
 RungeKuttaMethod --is_type_of--> OneStepMethod
 AdamsBashforth --is_type_of--> ExplicitMultistepMethod
 AdamsMoulton --is_type_of--> ImplicitMultistepMethod
 DenseOutput --supports--> EventLocation
 EventDetection --uses--> RootFindingForEvents
 SymplecticIntegrator --preserves_approximately--> HamiltonianStructure
 Verification --checks--> ODESolution
}

OPERATORS {
 ODE_IVP(f,t0,y0) := y'(t)=f(t,y), y(t0)=y0
 FORWARD_EULER(y_n,t_n,h,f) := y_(n+1)=y_n+h*f(t_n,y_n)
 BACKWARD_EULER(y_n,t_n,h,f) := solve(y_(n+1)=y_n+h*f(t_n+h,y_(n+1)))
 RK4_STEP(y,t,h,f) := classical_four_stage_RK4_update
 EMBEDDED_ERROR(y_high,y_low) := e=y_high-y_low
 ADAPTIVE_STEP(h,error,tol,p) := h_new=h*controller(error,tol,p)
 EVENT_FUNCTION(t,y) := g(t,y)
 ODE_RESIDUAL(y_dot,f,t,y) := r=y_dot-f(t,y)
}

AXIOMS {
 A1 = "An ODE solver approximates continuous evolution through discrete numerical steps."
 A2 = "Local truncation error and accumulated global error are distinct."
 A3 = "Explicit and implicit ODE methods have different stability and computational properties."
 A4 = "Adaptive ODE methods require error estimation and step-size control."
 A5 = "Stiff ODEs can make explicit stability restrictions much more severe than accuracy requirements."
 A6 = "Event detection requires interpolation or refinement between accepted steps."
 A7 = "Consistency, stability and convergence are distinct numerical properties."
 A8 = "ODE solver results require error, stability, convergence and reproducibility validation."
}

REASONING {
 R1_CONTEXT = identify(ODE_order,system_dimension,autonomous_or_nonautonomous,initial_or_boundary_conditions,stiffness,accuracy_goal)
 R2_REDUCE = if_higher_order convert_to_first_order_system_when_appropriate
 R3_METHOD = select(Euler,RungeKutta,multistep,BDF,Rosenbrock,collocation,symplectic_or_other_method)
 R4_CONFIGURATION = set(step_size,tolerances,max_steps,error_estimator,event_controls)
 R5_SUBSOLVERS = if_implicit configure(Jacobian,nonlinear_solver,linear_solver,preconditioner)
 R6_ADVANCE = compute_candidate_step
 R7_ERROR_CONTROL = estimate_local_error_and_accept_or_reject_step
 R8_EVENTS = detect_and_locate_events_if_present
 R9_STABILITY = assess(stiffness,stability_region,phase_dissipation_and_long_time_behaviour)
 R10_VALIDATE = check(convergence,reference_solution,invariants,solver_status_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Explicit ODE methods can be unstable when step sizes exceed their stability region."
 C2 = "Implicit ODE methods require accurate algebraic subsolves."
 C3 = "A small local error estimate does not guarantee small global error for an unstable integration."
 C4 = "Adaptive controllers can fail near discontinuities or rapidly changing time scales."
 C5 = "Stiffness can make explicit methods computationally impractical even when they are formally accurate."
 C6 = "Event location accuracy depends on interpolation and root-finding quality."
 C7 = "High-order methods can lose nominal order for nonsmooth forcing or state resets."
 C8 = "Long-time integrations can accumulate phase, energy or round-off drift."
 C9 = "Absolute tolerance alone can be unsuitable across variables with different scales."
 C10 = "Maximum-step or evaluation-limit termination is not equivalent to successful integration."
}

SEMANTIC_EQUIVALENCE {
 "OrdinaryDifferentialEquationSolver" <=> "ODESolver"
 "InitialValueProblem" <=> "IVP"
 "BoundaryValueProblem" <=> "BVP"
 "AdaptiveStepMethod" <=> "VariableStepMethod"
 "BackwardDifferentiationFormula" <=> "BDF"
 "RungeKuttaFehlberg" <=> "RKF45InCommonFourthFifthOrderContext"
}

VALIDATION {
 V1 = "ODE system and independent variable are explicit."
 V2 = "Initial or boundary conditions are documented."
 V3 = "Solver method and order are documented."
 V4 = "Absolute and relative tolerances are documented."
 V5 = "Step-size control and rejected-step behaviour are documented."
 V6 = "Implicit subsolver settings are documented where relevant."
 V7 = "Event functions and event-location tolerances are documented where relevant."
 V8 = "Convergence under step refinement is checked where feasible."
 V9 = "Reference, analytic or manufactured solutions are used where feasible."
 V10 = "Results are reproducible under documented arithmetic and solver settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 ODE_SOLVER_DEFINITION = 0.99
 EXPLICIT_METHOD_REASONING = 0.99
 IMPLICIT_METHOD_REASONING = 0.99
 RUNGE_KUTTA_REASONING = 0.99
 MULTISTEP_REASONING = 0.99
 STIFFNESS_REASONING = 0.98
 ADAPTIVE_STEP_REASONING = 0.99
 EVENT_REASONING = 0.98
 POLICY = "Reduce confidence when ODE structure, stiffness, initial conditions, tolerances, event definitions, subsolver settings or arithmetic precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, ODESolverReasoning,
  InitialValueProblemReasoning, TimeIntegratorReasoning,
  ExplicitMethodReasoning, ImplicitMethodReasoning,
  EulerReasoning, RungeKuttaReasoning, EmbeddedRungeKuttaReasoning,
  MultistepReasoning, BDFReasoning, StiffSolverReasoning,
  AdaptiveStepReasoning, EventDetectionReasoning,
  DenseOutputReasoning, LinearSubsolverReasoning,
  NonlinearSubsolverReasoning, StabilityReasoning,
  ErrorControlReasoning, LongTimeIntegrationReasoning,
  VerificationReasoning, KnowledgeGraphConstruction,
  RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "ODE solver" -> OrdinaryDifferentialEquationSolver
  "ordinary differential equation solver" -> OrdinaryDifferentialEquationSolver
  "IVP" -> InitialValueProblem
  "variable-step solver" -> AdaptiveStepMethod
  "BDF" -> BackwardDifferentiationFormula
  "RKF45" -> RungeKuttaFehlberg
 }
}

EXECUTION_RULES {
 E1 = "If an ordinary differential equation is integrated numerically, activate OrdinaryDifferentialEquationSolverOntology."
 E2 = "Reduce higher-order ODEs to first-order systems when required by the selected numerical method."
 E3 = "For nonstiff smooth systems, consider explicit Runge-Kutta or multistep methods."
 E4 = "For stiff systems, consider implicit Runge-Kutta, BDF, Rosenbrock or other stiffly suitable methods."
 E5 = "For adaptive stepping, define absolute and relative tolerances and use a compatible error estimator."
 E6 = "For implicit methods, configure Jacobian, nonlinear and linear subsolvers."
 E7 = "For event-driven problems, use dense output or step refinement to locate events accurately."
 E8 = "For Hamiltonian or long-time geometric problems, consider structure-preserving integrators."
 E9 = "Validate through step refinement, residuals, invariants, reference solutions and reproducibility."
}

RECURSION {
 ENTRY = OrdinaryDifferentialEquationSolver
 EXPAND(OrdinaryDifferentialEquationSolver) -> [
  ODESolver,OrdinaryDifferentialEquation,ODE,ODESystem,
  InitialValueProblem,IVP,BoundaryValueProblem,BVP,FirstOrderODE,
  HigherOrderODE,AutonomousODE,NonautonomousODE,ExplicitODE,
  ImplicitODE,LinearODE,NonlinearODE,StiffODE,NonstiffODE,
  TimeIntegrator,TimeStepping,OneStepMethod,MultistepMethod,
  ExplicitMethod,ImplicitMethod,FixedStepMethod,AdaptiveStepMethod,
  StepSize,StepSizeController,ErrorEstimator,EmbeddedMethod,
  LocalTruncationError,GlobalError,AbsoluteTolerance,RelativeTolerance,
  ForwardEuler,BackwardEuler,ImprovedEuler,HeunMethod,MidpointMethod,
  RungeKuttaMethod,RK2,RK3,RK4,EmbeddedRungeKutta,
  RungeKuttaFehlberg,RKF45,DormandPrince,CashKarp,
  BogackiShampine,AdamsBashforth,AdamsMoulton,PredictorCorrector,
  LinearMultistepMethod,BackwardDifferentiationFormula,BDF,
  GearMethod,ImplicitRungeKutta,DIRK,SDIRK,RadauMethod,
  GaussCollocation,RosenbrockMethod,ExponentialIntegrator,
  SymplecticIntegrator,VerletMethod,LeapfrogMethod,
  PartitionedIntegrator,Stiffness,StiffSolver,NonstiffSolver,
  StabilityRegion,AbsoluteStability,AStableMethod,LStableMethod,
  ZeroStability,Consistency,Convergence,OrderOfAccuracy,
  AdaptiveTimeStep,RejectedStep,AcceptedStep,DenseOutput,
  ContinuousExtension,Interpolation,EventDetection,EventLocation,
  EventFunction,RootFindingForEvents,Jacobian,MassMatrix,
  LinearSolver,NonlinearSolver,NewtonMethod,Preconditioner,
  Residual,Defect,ForwardError,BackwardError,PhaseError,
  DissipationError,LongTimeIntegration,Conservation,Invariant,
  EnergyPreservation,PositivityPreservation,SolverConfiguration,
  SolverStatus,MaximumSteps,FunctionEvaluationCount,
  FloatingPointArithmetic,MachinePrecision,RoundOffError,
  ParallelODESolver,DistributedODESolver,GPUODESolver,
  Verification,ManufacturedSolution,ReferenceSolution,
  BenchmarkProblem,Reproducibility
 ]
 EXPAND(ODESolverFamilies) -> [
  ExplicitOneStepSolvers,
  ExplicitRungeKuttaSolvers,
  EmbeddedAdaptiveRungeKuttaSolvers,
  LinearMultistepSolvers,
  StiffImplicitSolvers,
  StructurePreservingODESolvers,
  EventAwareODESolvers
 ]
 STOP_CONDITION = "Stop when ODE class, initial or boundary conditions, solver family, step control, stiffness, event handling, error and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Differential Equation Solver Ontology"
 RELATED_ONTOLOGIES = [
  "Differential Equation Solver Ontology",
  "Differential Equation Solvers",
  "Numerical Calculus",
  "Numerical Differentiation Ontology 2",
  "Equation Solver Ontology",
  "Linear Solver Ontology",
  "Nonlinear Solver Ontology",
  "Root Finding Ontology 2",
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology"
 ]
 ROUTE_RULES = [
  "ODE Solver -> Differential Equation Solver for parent solver semantics",
  "ODE Solver -> Numerical Differentiation for derivative and Jacobian approximation",
  "ODE Solver -> Equation Solver for implicit stage equations",
  "ODE Solver -> Linear Solver for linearised implicit systems",
  "ODE Solver -> Nonlinear Solver for nonlinear implicit stages",
  "ODE Solver -> Root Finding for event localisation",
  "ODE Solver -> Numerical Analysis for consistency, stability and convergence",
  "ODE Solver -> Numerical Error for local and global error semantics",
  "ODE Solver -> Numerical Stability for stiff and finite-precision behaviour",
  "ODE Solver -> Floating Point Arithmetic for long-time round-off effects"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible ODE solver families, controllers or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve ODE-versus-PDE distinction.",
  "Preserve initial-value-versus-boundary-value distinction.",
  "Preserve explicit-versus-implicit solver distinction.",
  "Preserve one-step-versus-multistep distinction.",
  "Preserve fixed-step-versus-adaptive-step distinction.",
  "Preserve local-error-versus-global-error distinction.",
  "Preserve stiff-versus-nonstiff problem distinction.",
  "Preserve event-location-versus-time-step semantics.",
  "Preserve machine-readable ODE-solver semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "An ordinary differential equation solver numerically advances or computes a solution of an ODE or ODE system."
 EXPLICIT_SUMMARY = "Explicit Euler, Runge-Kutta and Adams-Bashforth methods advance without nonlinear algebraic solves."
 IMPLICIT_SUMMARY = "Backward Euler, BDF, implicit Runge-Kutta and Rosenbrock-type methods target improved stability and often require algebraic subsolvers."
 ADAPTIVE_SUMMARY = "Embedded methods estimate local error and vary step size to meet absolute and relative tolerances."
 STIFFNESS_SUMMARY = "Stiff ODEs favour methods with appropriate A-stable, L-stable or related stability properties."
 EVENT_SUMMARY = "Event detection combines time stepping with interpolation and root finding to locate state transitions."
 VALIDATION_SUMMARY = "ODE solver results should be checked through step refinement, stability, event accuracy, invariants, reference solutions and reproducibility."
}

FLOW {
 INPUT
 -> detect_ODE_solver_context
 -> identify_ODE_order_system_dimension_autonomous_or_nonautonomous_initial_or_boundary_conditions_stiffness_and_accuracy_goal
 -> if_higher_order_reduce_to_first_order_system_when_required
 -> select_Euler_RungeKutta_multistep_BDF_Rosenbrock_collocation_symplectic_exponential_or_other_method
 -> configure_step_size_tolerances_max_steps_error_estimator_and_event_controls
 -> if_implicit_configure_Jacobian_nonlinear_solver_linear_solver_and_preconditioner
 -> compute_candidate_step
 -> estimate_error_and_accept_or_reject_step
 -> detect_and_locate_events_if_present
 -> monitor_stability_stiffness_phase_dissipation_constraints_and_long_time_behaviour
 -> adapt_step_size_or_solver_configuration_if_required
 -> classify_solver_status
 -> assess_local_global_and_roundoff_error
 -> validate_against_reference_analytic_manufactured_or_benchmark_solution
 -> route_to_related_parent_equation_solver_root_finding_analysis_error_stability_convergence_and_floating_point_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Ordinary Differential Equation Solver Ontology defines numerical methods for ODEs and ODE systems. It supports initial-value and boundary-value problems, first- and higher-order equations, explicit and implicit methods, Euler, Runge-Kutta, embedded Runge-Kutta, RKF45, Dormand-Prince, Cash-Karp and Bogacki-Shampine schemes, Adams-Bashforth and Adams-Moulton methods, BDF and Gear methods, implicit Runge-Kutta, DIRK, SDIRK, Radau, collocation and Rosenbrock methods, exponential and symplectic integrators, fixed and adaptive stepping, stiffness, stability regions, dense output, event detection and root finding, Jacobian-based subsolvers, local and global error, phase and dissipation error, long-time integration, invariant preservation, finite precision, verification, benchmarking and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-ORDINARY-DIFFERENTIAL-EQUATION-SOLVER-ONTOLOGY-V1"
}

}

END_FLOW