Differential Equation Solvers

AI INTERPRETATION NOTE
This Flow Algebra defines the Differential Equation Solvers parent ontology within the Kireth Research Semantic Library. Differential equation solvers are computational methods for approximating solutions of ordinary, partial and differential-algebraic equations. This ontology supports initial-value and boundary-value problems, explicit and implicit time integration, Runge-Kutta and multistep methods, stiff systems, adaptive step-size control, finite difference, finite volume and finite element discretisation, operator splitting, stability, consistency, convergence, error control, nonlinear and linear subsolvers, event handling, verification and reproducibility.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = DifferentialEquationSolvers
 ENTITY_CLASS = ComputationalDifferentialEquationSolutionFramework
 PRIMARY_CONTEXT = ComputationalMathematicsOntologies
 DEFINITION = "Differential equation solvers are numerical methods that approximate functions satisfying ordinary, partial or differential-algebraic equations under specified initial, boundary and constraint conditions."
 SYMBOLIC_FORMS = [
  "y'(t)=f(t,y)",
  "F(t,y,y')=0",
  "L(u)=f",
  "u_t=N(u)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for numerical integration of differential equations, spatial discretisation, time stepping, adaptive control, stiffness, stability, error estimation, solver coupling and verification."
}

SCOPE {
 INCLUDE = [
  DifferentialEquationSolver, DifferentialEquationSolvers,
  OrdinaryDifferentialEquation, ODE, PartialDifferentialEquation, PDE,
  DifferentialAlgebraicEquation, DAE, InitialValueProblem, IVP,
  BoundaryValueProblem, BVP, InitialBoundaryValueProblem,
  ExplicitMethod, ImplicitMethod, OneStepMethod, MultistepMethod,
  TimeIntegrator, TimeStepping, TimeStep, AdaptiveTimeStep,
  FixedTimeStep, StepSizeControl, LocalTruncationError, GlobalError,
  ErrorEstimator, EmbeddedMethod, DenseOutput, Interpolation,
  EventDetection, EventLocation, RootFindingForEvents,
  EulerMethod, ForwardEuler, BackwardEuler, ImprovedEuler,
  HeunMethod, MidpointMethod, RungeKuttaMethod, RK2, RK3, RK4,
  EmbeddedRungeKutta, RungeKuttaFehlberg, RKF45, DormandPrince,
  CashKarp, BogackiShampine, AdamsBashforth, AdamsMoulton,
  PredictorCorrector, BackwardDifferentiationFormula, BDF,
  GearMethod, LinearMultistepMethod, StabilityRegion,
  AbsoluteStability, AStableMethod, LStableMethod, StiffEquation,
  Stiffness, StiffSolver, NonstiffSolver, ImplicitRungeKutta,
  RosenbrockMethod, SDIRK, DIRK, RadauMethod, GaussCollocation,
  SymplecticIntegrator, VerletMethod, LeapfrogMethod,
  PartitionedIntegrator, ExponentialIntegrator,
  OperatorSplitting, LieSplitting, StrangSplitting,
  MethodOfLines, SpatialDiscretisation, TemporalDiscretisation,
  FiniteDifferenceMethod, FiniteVolumeMethod, FiniteElementMethod,
  SpectralMethod, CollocationMethod, GalerkinMethod,
  Mesh, Grid, AdaptiveMesh, MeshRefinement, AMR,
  CFLCondition, CourantNumber, StabilityLimit,
  LinearSolver, NonlinearSolver, NewtonMethod, Jacobian,
  MassMatrix, ConstraintEquation, IndexOfDAE,
  Consistency, Convergence, Stability, ZeroStability,
  ConsistencyOrder, OrderOfAccuracy, PhaseError, DissipationError,
  NumericalDispersion, NumericalDiffusion, Conservation,
  PositivityPreservation, Monotonicity, ShockCapturing,
  SourceTerm, Flux, BoundaryCondition, DirichletBoundaryCondition,
  NeumannBoundaryCondition, RobinBoundaryCondition, PeriodicBoundaryCondition,
  InitialCondition, ConstraintCondition, Residual, Defect,
  Verification, Validation, ManufacturedSolution,
  MethodOfManufacturedSolutions, ReferenceSolution,
  BenchmarkProblem, Reproducibility, FloatingPointArithmetic,
  MachinePrecision, RoundOffError, ComputationalComplexity,
  MemoryComplexity, ParallelSolver, DistributedSolver, GPUSolver
 ]
 EXCLUDE_AS_PRIMARY = [
  ExactSymbolicDifferentialEquationSolutionWithoutNumericalApproximation,
  PureAlgebraicEquationSolvingWithoutDifferentialStructure,
  OptimisationWithoutDifferentialEquationDynamics,
  StaticInterpolationWithoutDifferentialEquationContext
 ]
 DISAMBIGUATION_RULE = "When the task is to numerically approximate a function governed by differential equations in time, space or both, interpret the context as differential equation solvers."
}

CORE_CONCEPTS {
 DifferentialEquationSolver = "Computational method for approximating solutions of differential equations."
 InitialValueProblem = "Differential equation problem specified with data at an initial point or time."
 BoundaryValueProblem = "Differential equation problem constrained by values or derivative conditions at boundaries."
 TimeIntegrator = "Method advancing a differential system from one time level to another."
 Stiffness = "Property causing explicit methods to require very small steps for stability relative to solution time scales."
 AdaptiveTimeStep = "Variable step-size strategy controlled by an error estimator."
 MethodOfLines = "Reduction of PDEs to systems of ODEs by discretising space first."
 Stability = "Control of perturbation growth under the numerical method."
 Consistency = "Agreement of the discrete equations with the differential equation as resolution tends to zero."
 Convergence = "Approach of the numerical solution to the exact solution as discretisation is refined."
}

RELATIONS {
 DifferentialEquationSolvers --is_child_of--> ComputationalMathematicsOntologies
 ODE --is_solved_by--> TimeIntegrator
 PDE --can_be_reduced_by--> MethodOfLines
 MethodOfLines --produces--> ODESystem
 ExplicitMethod --advances_without--> NonlinearSolve
 ImplicitMethod --often_requires--> NonlinearSolver
 NonlinearSolver --often_uses--> LinearSolver
 AdaptiveTimeStep --uses--> ErrorEstimator
 EmbeddedRungeKutta --provides--> LocalErrorEstimate
 StiffEquation --favours--> StiffSolver
 BackwardDifferentiationFormula --is_type_of--> ImplicitMultistepMethod
 RungeKuttaMethod --is_type_of--> OneStepMethod
 AdamsBashforth --is_type_of--> ExplicitMultistepMethod
 AdamsMoulton --is_type_of--> ImplicitMultistepMethod
 FiniteDifferenceMethod --discretises--> SpatialDerivative
 FiniteVolumeMethod --discretises--> ConservationLaw
 FiniteElementMethod --discretises--> WeakForm
 CFLCondition --limits--> ExplicitTimeStep
 Consistency --with_stability_supports--> Convergence
 Verification --checks--> NumericalSolution
}

OPERATORS {
 ODE_IVP(f,t0,y0) := y'(t)=f(t,y), y(t0)=y0
 FORWARD_EULER(y_n,f_n,h) := y_(n+1)=y_n+h*f_n
 BACKWARD_EULER(y_n,h,f) := solve(y_(n+1)=y_n+h*f(t_(n+1),y_(n+1)))
 RK4_STEP(y,t,h,f) := y_next=classical_four_stage_RK4(y,t,h,f)
 ADAPTIVE_STEP(error,tol,h) := h_new=h*controller(error,tol)
 METHOD_OF_LINES(PDE,space_discretisation) := ODE_system_in_time
 RESIDUAL(discrete_operator,u) := discrete_operator(u)-forcing
 CFL(dt,dx,speed) := speed*dt/dx
}

AXIOMS {
 A1 = "Differential equation solvers approximate continuous differential problems through finite numerical representations."
 A2 = "Consistency, stability and convergence are distinct numerical properties."
 A3 = "Local truncation error and global solution error are distinct."
 A4 = "Stiff problems can require implicit or specially stabilised methods."
 A5 = "Adaptive stepping requires an error estimator and a step-size controller."
 A6 = "PDE solvers couple spatial and temporal discretisation semantics."
 A7 = "Boundary and initial conditions are part of the mathematical problem, not optional metadata."
 A8 = "Differential equation solver results require error, stability, convergence and reproducibility validation."
}

REASONING {
 R1_CONTEXT = identify(equation_type,dimension,time_dependence,initial_conditions,boundary_conditions,constraints,accuracy_goal)
 R2_CLASSIFY = classify(ODE,PDE,DAE,IVP,BVP,stiff,nonstiff,hyperbolic,parabolic,elliptic_or_mixed)
 R3_DISCRETISE = if_PDE choose(spatial_discretisation_and_mesh)
 R4_TIME_METHOD = if_time_dependent choose(explicit,implicit,RungeKutta,multistep,exponential,splitting_or_symplectic_method)
 R5_STEP_CONTROL = choose(fixed_or_adaptive_step_and_error_estimator)
 R6_SUBSOLVERS = if_implicit choose(nonlinear_solver,linear_solver,Jacobian_and_preconditioner)
 R7_EXECUTE = advance_solution_or_solve_discrete_system
 R8_STABILITY = assess(stability_region,CFL,stiffness,dispersion,dissipation_and_constraint_preservation)
 R9_ERROR = assess(local_error,global_error,spatial_error,temporal_error_and_roundoff)
 R10_VALIDATE = check(convergence,conservation,boundary_conditions,reference_solution_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Explicit methods can be unstable when time steps violate method or CFL stability limits."
 C2 = "Implicit methods require accurate solution of algebraic systems at each step."
 C3 = "A small local error estimate does not guarantee small global error in unstable or ill-conditioned problems."
 C4 = "PDE convergence depends jointly on spatial and temporal discretisation."
 C5 = "Stiffness is problem- and method-dependent."
 C6 = "High-order methods can lose nominal order near discontinuities, events or nonsmooth forcing."
 C7 = "Adaptive step controllers can fail near singularities or rapidly varying scales."
 C8 = "DAE solvers require consistency with algebraic constraints and index structure."
 C9 = "Conservation, positivity or symplectic structure may be lost by unsuitable methods."
 C10 = "Finite precision can cause long-time drift, stagnation or loss of invariants."
}

SEMANTIC_EQUIVALENCE {
 "DifferentialEquationSolver" <=> "NumericalDifferentialEquationSolver"
 "InitialValueProblem" <=> "IVP"
 "BoundaryValueProblem" <=> "BVP"
 "OrdinaryDifferentialEquation" <=> "ODE"
 "PartialDifferentialEquation" <=> "PDE"
 "DifferentialAlgebraicEquation" <=> "DAE"
 "AdaptiveMeshRefinement" <=> "AMR"
}

VALIDATION {
 V1 = "Differential equation, variables and domain are explicit."
 V2 = "Initial and boundary conditions are documented."
 V3 = "Spatial and temporal discretisations are documented."
 V4 = "Solver order and stability assumptions are documented."
 V5 = "Step-size or mesh-refinement strategy is documented."
 V6 = "Implicit subsolvers and tolerances are documented where relevant."
 V7 = "Convergence under refinement is checked where feasible."
 V8 = "Conservation, positivity or invariant properties are checked where relevant."
 V9 = "Reference or manufactured solutions are used where feasible."
 V10 = "Results are reproducible under documented arithmetic and solver settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 DIFFERENTIAL_EQUATION_SOLVER_DEFINITION = 0.99
 ODE_REASONING = 0.99
 PDE_REASONING = 0.99
 STIFFNESS_REASONING = 0.98
 ADAPTIVE_TIME_STEPPING_REASONING = 0.99
 IMPLICIT_SOLVER_REASONING = 0.98
 STABILITY_REASONING = 0.99
 POLICY = "Reduce confidence when equation class, boundary or initial conditions, stiffness, discretisation, solver tolerances, mesh resolution or arithmetic precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, DifferentialEquationSolverReasoning,
  ODESolverReasoning, PDESolverReasoning, DAESolverReasoning,
  InitialValueProblemReasoning, BoundaryValueProblemReasoning,
  RungeKuttaReasoning, MultistepReasoning, StiffSolverReasoning,
  AdaptiveTimeSteppingReasoning, MethodOfLinesReasoning,
  FiniteDifferenceReasoning, FiniteVolumeReasoning,
  FiniteElementReasoning, StabilityReasoning, CFLReasoning,
  ConvergenceReasoning, ErrorControlReasoning,
  LinearSubsolverReasoning, NonlinearSubsolverReasoning,
  VerificationReasoning, KnowledgeGraphConstruction,
  RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "differential equation solver" -> DifferentialEquationSolver
  "ODE solver" -> DifferentialEquationSolver
  "PDE solver" -> DifferentialEquationSolver
  "DAE solver" -> DifferentialEquationSolver
  "IVP" -> InitialValueProblem
  "BVP" -> BoundaryValueProblem
  "AMR" -> AdaptiveMeshRefinement
 }
}

EXECUTION_RULES {
 E1 = "If a differential equation is approximated numerically, activate DifferentialEquationSolvers."
 E2 = "Classify ODE, PDE or DAE structure before selecting a solver."
 E3 = "For PDEs, specify spatial discretisation before or together with time integration."
 E4 = "For stiff systems, consider A-stable, L-stable or other stiffly suitable methods."
 E5 = "For adaptive integration, use explicit local-error estimation and step-size control."
 E6 = "For implicit methods, define nonlinear and linear subsolver semantics."
 E7 = "Respect CFL or related stability restrictions for explicit discretisations."
 E8 = "Preserve relevant conservation, positivity, symplectic or constraint structure when method choice permits."
 E9 = "Validate using refinement, residuals, reference solutions, invariants and reproducibility."
}

RECURSION {
 ENTRY = DifferentialEquationSolvers
 EXPAND(DifferentialEquationSolvers) -> [
  DifferentialEquationSolver,OrdinaryDifferentialEquation,ODE,
  PartialDifferentialEquation,PDE,DifferentialAlgebraicEquation,DAE,
  InitialValueProblem,IVP,BoundaryValueProblem,BVP,
  InitialBoundaryValueProblem,ExplicitMethod,ImplicitMethod,
  OneStepMethod,MultistepMethod,TimeIntegrator,TimeStepping,
  TimeStep,AdaptiveTimeStep,FixedTimeStep,StepSizeControl,
  LocalTruncationError,GlobalError,ErrorEstimator,EmbeddedMethod,
  DenseOutput,EventDetection,RootFindingForEvents,EulerMethod,
  ForwardEuler,BackwardEuler,HeunMethod,MidpointMethod,
  RungeKuttaMethod,RK2,RK3,RK4,EmbeddedRungeKutta,
  RungeKuttaFehlberg,DormandPrince,CashKarp,BogackiShampine,
  AdamsBashforth,AdamsMoulton,PredictorCorrector,
  BackwardDifferentiationFormula,BDF,GearMethod,
  LinearMultistepMethod,StabilityRegion,AbsoluteStability,
  AStableMethod,LStableMethod,StiffEquation,Stiffness,
  StiffSolver,NonstiffSolver,ImplicitRungeKutta,RosenbrockMethod,
  SDIRK,DIRK,RadauMethod,GaussCollocation,SymplecticIntegrator,
  VerletMethod,LeapfrogMethod,PartitionedIntegrator,
  ExponentialIntegrator,OperatorSplitting,LieSplitting,StrangSplitting,
  MethodOfLines,SpatialDiscretisation,TemporalDiscretisation,
  FiniteDifferenceMethod,FiniteVolumeMethod,FiniteElementMethod,
  SpectralMethod,CollocationMethod,GalerkinMethod,Mesh,Grid,
  AdaptiveMesh,MeshRefinement,AMR,CFLCondition,CourantNumber,
  LinearSolver,NonlinearSolver,NewtonMethod,Jacobian,MassMatrix,
  IndexOfDAE,Consistency,Convergence,Stability,ZeroStability,
  OrderOfAccuracy,NumericalDispersion,NumericalDiffusion,
  Conservation,PositivityPreservation,BoundaryCondition,
  InitialCondition,Residual,Defect,Verification,Validation,
  ManufacturedSolution,ReferenceSolution,BenchmarkProblem,
  Reproducibility,FloatingPointArithmetic,MachinePrecision,
  ComputationalComplexity,ParallelSolver,DistributedSolver,GPUSolver
 ]
 EXPAND(SolverFamilies) -> [
  ExplicitODESolvers,
  ImplicitODESolvers,
  RungeKuttaSolvers,
  MultistepSolvers,
  StiffSolvers,
  DAESolvers,
  BoundaryValueSolvers,
  PDESolvers,
  AdaptiveAndStructurePreservingSolvers
 ]
 STOP_CONDITION = "Stop when equation class, initial and boundary conditions, discretisation, time integrator, stability, error control, subsolvers and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics Ontologies"
 RELATED_ONTOLOGIES = [
  "Numerical Calculus",
  "Numerical Differentiation Ontology 2",
  "Quadrature Ontology",
  "Equation Solver Ontology",
  "Linear Solver Ontology",
  "Nonlinear Solver Ontology",
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Scientific Computing Ontology 2"
 ]
 ROUTE_RULES = [
  "Differential Equation Solvers -> Computational Mathematics for parent semantics",
  "Differential Equation Solvers -> Numerical Differentiation for spatial derivative discretisation",
  "Differential Equation Solvers -> Quadrature for collocation, finite element and integral formulations",
  "Differential Equation Solvers -> Equation Solver for algebraic systems arising from discretisation",
  "Differential Equation Solvers -> Linear Solver for implicit and spatial linear systems",
  "Differential Equation Solvers -> Nonlinear Solver for nonlinear implicit steps",
  "Differential Equation Solvers -> Numerical Analysis for consistency, stability and convergence",
  "Differential Equation Solvers -> Numerical Error for local and global error semantics",
  "Differential Equation Solvers -> Floating Point Arithmetic for long-time finite-precision effects",
  "Differential Equation Solvers -> Scientific Computing for large-scale implementation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible solver families, discretisations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve ODE-versus-PDE-versus-DAE distinction.",
  "Preserve initial-value-versus-boundary-value distinction.",
  "Preserve explicit-versus-implicit distinction.",
  "Preserve spatial-versus-temporal discretisation distinction.",
  "Preserve local-error-versus-global-error distinction.",
  "Preserve stiffness-versus-nonstiffness distinction.",
  "Preserve mathematical-problem-versus-discrete-system distinction.",
  "Preserve machine-readable differential-equation-solver semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Differential equation solvers numerically approximate functions satisfying ODEs, PDEs or DAEs under specified initial, boundary and constraint conditions."
 ODE_SUMMARY = "ODE solvers include Euler, Runge-Kutta, multistep, implicit, stiff and adaptive time-integration methods."
 PDE_SUMMARY = "PDE solvers combine spatial discretisation such as finite differences, finite volumes, finite elements or spectral methods with algebraic and time-integration solvers."
 STIFFNESS_SUMMARY = "Stiff systems require methods with stability properties suitable for widely separated time scales."
 ADAPTIVITY_SUMMARY = "Adaptive time stepping and mesh refinement allocate resolution according to error estimates."
 SUBSOLVER_SUMMARY = "Implicit differential-equation methods often require nonlinear and linear equation solvers at each step."
 VALIDATION_SUMMARY = "Differential equation results should be checked for residuals, convergence under refinement, stability, invariants, reference solutions and reproducibility."
}

FLOW {
 INPUT
 -> detect_differential_equation_solver_context
 -> identify_equation_type_domain_initial_conditions_boundary_conditions_constraints_and_accuracy_goal
 -> classify_ODE_PDE_DAE_IVP_BVP_stiff_nonstiff_and_equation_character
 -> if_PDE_select_spatial_discretisation_and_mesh
 -> select_explicit_implicit_RungeKutta_multistep_stiff_exponential_splitting_symplectic_or_other_solver
 -> choose_fixed_or_adaptive_time_step_and_error_estimator
 -> if_implicit_configure_nonlinear_linear_Jacobian_and_preconditioner_subsolvers
 -> execute_time_advance_or_discrete_solve
 -> monitor_stability_CFL_residuals_error_estimates_events_constraints_and_invariants
 -> assess_spatial_temporal_roundoff_dispersion_dissipation_and_global_error
 -> refine_time_step_mesh_or_solver_configuration_if_required
 -> validate_against_manufactured_reference_or_benchmark_solution_and_reproducibility
 -> route_to_related_numerical_calculus_equation_solver_analysis_error_stability_convergence_floating_point_and_scientific_computing_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Differential Equation Solvers ontology defines numerical methods for ODEs, PDEs and DAEs. It supports initial-value and boundary-value problems, explicit and implicit methods, Euler, Runge-Kutta and embedded adaptive methods, Adams and backward differentiation formulas, stiff solvers, implicit Runge-Kutta, Rosenbrock, DIRK, Radau and collocation methods, symplectic and exponential integrators, operator splitting, event detection, method of lines, finite difference, finite volume, finite element and spectral discretisations, mesh and time-step adaptivity, CFL restrictions, linear and nonlinear subsolvers, DAE constraints and mass matrices, consistency, stability, convergence, numerical dispersion and diffusion, conservation and positivity, verification with manufactured solutions, benchmarking, parallel and GPU computation, and reproducibility."
}

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

}

END_FLOW