Runge-Kutta Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Runge-Kutta Ontology within the Kireth Research Semantic Library. Runge-Kutta methods are one-step numerical integration schemes for ordinary differential equations that combine multiple stage evaluations within each step to achieve higher-order accuracy. This ontology supports explicit and implicit Runge-Kutta methods, Butcher tableaux, stage equations, embedded pairs, adaptive step-size control, stability functions, stiffly accurate variants, symplectic and collocation relationships, error estimation, finite precision and verification.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = RungeKuttaMethod
 ENTITY_CLASS = MultiStageOneStepTimeIntegrationFramework
 PRIMARY_CONTEXT = OrdinaryDifferentialEquationSolver
 DEFINITION = "A Runge-Kutta method advances an ODE solution over one time step by combining multiple intermediate stage evaluations of the differential equation."
 SYMBOLIC_FORMS = [
  "k_i=f(t_n+c_i*h, y_n+h*sum_j a_ij*k_j)",
  "y_(n+1)=y_n+h*sum_i b_i*k_i",
  "ButcherTableau=(A,b,c)",
  "R(z)=stability_function(z)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for multi-stage one-step integration, explicit and implicit Runge-Kutta methods, Butcher coefficients, order conditions, embedded pairs, adaptive control, stability and verification."
}

SCOPE {
 INCLUDE = [
  RungeKuttaMethod, RungeKuttaSolver, RKMethod,
  OneStepMethod, MultiStageMethod, Stage, StageDerivative,
  ButcherTableau, ButcherMatrix, ButcherVector, StageAbscissa,
  CoefficientMatrix, WeightVector, NodeVector,
  ExplicitRungeKutta, ImplicitRungeKutta,
  DiagonallyImplicitRungeKutta, DIRK,
  SinglyDiagonallyImplicitRungeKutta, SDIRK,
  FullyImplicitRungeKutta, CollocationMethod,
  GaussLegendreRungeKutta, RadauRungeKutta,
  LobattoRungeKutta, StifflyAccurateRungeKutta,
  LStableRungeKutta, AStableRungeKutta,
  ClassicalRK4, RK4, RK3, RK2, MidpointMethod,
  HeunMethod, RalstonMethod, KuttaThirdOrder,
  EmbeddedRungeKutta, EmbeddedPair,
  RungeKuttaFehlberg, RKF45, DormandPrince,
  CashKarp, BogackiShampine, FehlbergPair,
  LocalErrorEstimate, ErrorEstimator,
  AdaptiveStepSize, StepSizeController, SafetyFactor,
  AcceptedStep, RejectedStep, DenseOutput,
  ContinuousExtension, Interpolant,
  OrderCondition, ButcherTree, RootedTree,
  ElementaryWeight, OrderOfAccuracy,
  Consistency, Convergence, Stability,
  AbsoluteStability, StabilityRegion, StabilityFunction,
  AStability, LStability, AlgebraicStability,
  SSPRungeKutta, StrongStabilityPreservingMethod,
  Monotonicity, PositivityPreservation,
  SymplecticRungeKutta, PartitionedRungeKutta,
  IMEXRungeKutta, AdditiveRungeKutta,
  StiffEquation, Stiffness, NonstiffEquation,
  Jacobian, NonlinearStageSystem, NonlinearSolver,
  NewtonMethod, LinearSolver, Preconditioner,
  StageResidual, StageConvergenceTolerance,
  FunctionEvaluationCount, JacobianEvaluationCount,
  ComputationalCost, MemoryCost,
  FloatingPointArithmetic, MachinePrecision, RoundOffError,
  LongTimeIntegration, PhaseError, DissipationError,
  Verification, ReferenceSolution, ManufacturedSolution,
  BenchmarkProblem, Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  EulerMethodExceptAsFirstOrderRungeKuttaSpecialCase,
  LinearMultistepMethodWithoutRungeKuttaStages,
  GeneralCollocationWithoutTimeIntegrationSemantics,
  SymbolicODESolutionWithoutNumericalTimeStepping
 ]
 DISAMBIGUATION_RULE = "When an ODE time step is advanced through multiple internal stage evaluations combined by Butcher coefficients, interpret the context as a Runge-Kutta method."
}

CORE_CONCEPTS {
 RungeKuttaMethod = "One-step method combining multiple stage evaluations."
 ButcherTableau = "Structured representation of Runge-Kutta stage coefficients A, weights b and abscissae c."
 ExplicitRungeKutta = "Runge-Kutta method with strictly lower-triangular stage matrix."
 ImplicitRungeKutta = "Runge-Kutta method whose stage equations are coupled or implicit."
 EmbeddedPair = "Two Runge-Kutta formulas sharing stages but using different weights to estimate local error."
 OrderCondition = "Algebraic condition on Butcher coefficients required to achieve a specified order."
 StabilityFunction = "Rational or polynomial function describing the method on the linear test equation."
 DenseOutput = "Continuous approximation within a completed Runge-Kutta step."
}

RELATIONS {
 RungeKuttaMethod --is_child_of--> OrdinaryDifferentialEquationSolver
 RungeKuttaMethod --is_type_of--> OneStepMethod
 RungeKuttaMethod --uses--> ButcherTableau
 ButcherTableau --contains--> ButcherMatrix
 ButcherTableau --contains--> WeightVector
 ButcherTableau --contains--> StageAbscissa
 ExplicitRungeKutta --has--> StrictlyLowerTriangularButcherMatrix
 ImplicitRungeKutta --has--> ImplicitStageEquations
 EmbeddedRungeKutta --provides--> LocalErrorEstimate
 AdaptiveStepSize --uses--> LocalErrorEstimate
 OrderCondition --determines--> OrderOfAccuracy
 StabilityFunction --determines--> AbsoluteStabilityRegion
 StiffEquation --favours--> StifflyStableRungeKutta
 DIRK --reduces--> ImplicitStageCoupling
 NonlinearStageSystem --is_solved_by--> NonlinearSolver
 NonlinearSolver --often_uses--> LinearSolver
 SymplecticRungeKutta --preserves--> GeometricStructure
 Verification --checks--> RungeKuttaSolution
}

OPERATORS {
 RK_STAGE(i) := k_i=f(t_n+c_i*h, y_n+h*sum_j a_ij*k_j)
 RK_UPDATE(y_n,h,b,k) := y_(n+1)=y_n+h*sum_i b_i*k_i
 EMBEDDED_UPDATE(y_n,h,b_hat,k) := y_hat=y_n+h*sum_i b_hat_i*k_i
 EMBEDDED_ERROR(y_high,y_low) := e=y_high-y_low
 STABILITY_FUNCTION(A,b,z) := R(z)=1+z*b^T*(I-z*A)^(-1)*1
 ADAPTIVE_STEP(h,error,tol,p) := h_new=h*safety*(tol/error)^(1/(p+1))
 STAGE_RESIDUAL(K) := nonlinear_stage_equation_mismatch(K)
}

AXIOMS {
 A1 = "Runge-Kutta methods are one-step methods whose internal stages approximate the vector field within a step."
 A2 = "Explicit Runge-Kutta methods compute stages sequentially without nonlinear stage solves."
 A3 = "Implicit Runge-Kutta methods generally require coupled or sequential nonlinear stage solves."
 A4 = "Runge-Kutta order is determined by algebraic conditions on Butcher coefficients."
 A5 = "Embedded pairs estimate local error by comparing two formulas sharing stage evaluations."
 A6 = "Stability properties depend on the method's stability function, not only its formal order."
 A7 = "Higher stage count can increase accuracy or stability at greater computational cost."
 A8 = "Runge-Kutta results require coefficient, error, stability and reproducibility validation."
}

REASONING {
 R1_CONTEXT = identify(ODE_system,stiffness,accuracy_goal,cost_constraints,event_requirements)
 R2_FAMILY = select(explicit,embedded,DIRK,SDIRK,fully_implicit,collocation,SSP,symplectic_or_IMEX_family)
 R3_TABLEAU = load_or_define(A,b,c,and_optional_embedded_weights)
 R4_STAGE_SOLVE = compute_stage_values_sequentially_or_with_nonlinear_solver
 R5_UPDATE = combine_stage_derivatives_into_candidate_solution
 R6_ERROR_CONTROL = if_embedded estimate_local_error_and_accept_or_reject_step
 R7_STABILITY = analyse(stability_function,stiffness,A_stability,L_stability_or_SSP_properties)
 R8_COST = assess(function_evaluations,Jacobian_evaluations,linear_solves_and_memory)
 R9_DENSE_OUTPUT = if_required construct_continuous_extension
 R10_VALIDATE = check(order,step_refinement,reference_solution,stage_residuals_and_reproducibility)
}

CONSTRAINTS {
 C1 = "High formal order does not guarantee suitable stability for stiff systems."
 C2 = "Explicit Runge-Kutta methods can require restrictive step sizes on stiff problems."
 C3 = "Implicit Runge-Kutta methods require accurate nonlinear stage solves."
 C4 = "Incorrect Butcher coefficients invalidate order and stability properties."
 C5 = "Embedded error estimators can be unreliable near discontinuities or nonsmooth dynamics."
 C6 = "Adaptive controllers can reject many steps when the solution changes abruptly."
 C7 = "Dense-output order may differ from the main method order."
 C8 = "SSP properties hold only under stated coefficient and step-size conditions."
 C9 = "Finite-precision round-off can dominate at very small step sizes."
 C10 = "Stage convergence tolerances that are too loose can spoil the nominal method accuracy."
}

SEMANTIC_EQUIVALENCE {
 "RungeKuttaMethod" <=> "RKMethod"
 "ClassicalRK4" <=> "RK4"
 "RungeKuttaFehlberg" <=> "RKF45"
 "DiagonallyImplicitRungeKutta" <=> "DIRK"
 "SinglyDiagonallyImplicitRungeKutta" <=> "SDIRK"
 "StrongStabilityPreservingMethod" <=> "SSPRungeKutta"
}

VALIDATION {
 V1 = "Butcher tableau is explicit or reproducibly identified."
 V2 = "Method order is documented."
 V3 = "Explicit versus implicit stage structure is documented."
 V4 = "Adaptive tolerances and controller parameters are documented."
 V5 = "Implicit stage-solver tolerances are documented."
 V6 = "Stability properties are checked against problem stiffness."
 V7 = "Observed order under step refinement is checked where feasible."
 V8 = "Dense-output properties are documented where used."
 V9 = "Reference or manufactured solutions are used where feasible."
 V10 = "Results are reproducible under documented arithmetic and solver settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 RUNGE_KUTTA_DEFINITION = 0.99
 EXPLICIT_RK_REASONING = 0.99
 IMPLICIT_RK_REASONING = 0.99
 EMBEDDED_RK_REASONING = 0.99
 ORDER_CONDITION_REASONING = 0.98
 STABILITY_REASONING = 0.99
 STIFF_RK_REASONING = 0.98
 POLICY = "Reduce confidence when Butcher coefficients, method order, stiffness, stage tolerances, adaptive controller or arithmetic precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, RungeKuttaReasoning,
  ButcherTableauReasoning, ExplicitRKReasoning,
  ImplicitRKReasoning, EmbeddedRKReasoning,
  AdaptiveStepReasoning, OrderConditionReasoning,
  StabilityFunctionReasoning, StiffRKReasoning,
  DIRKReasoning, SDIRKReasoning, CollocationReasoning,
  SSPReasoning, SymplecticRKReasoning, IMEXReasoning,
  StageSolverReasoning, DenseOutputReasoning,
  VerificationReasoning, KnowledgeGraphConstruction,
  RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "Runge-Kutta" -> RungeKuttaMethod
  "RK method" -> RungeKuttaMethod
  "RK4" -> ClassicalRK4
  "RKF45" -> RungeKuttaFehlberg
  "DIRK" -> DiagonallyImplicitRungeKutta
  "SDIRK" -> SinglyDiagonallyImplicitRungeKutta
  "SSP RK" -> SSPRungeKutta
 }
}

EXECUTION_RULES {
 E1 = "If an ODE step uses multiple internal stage evaluations combined by Butcher coefficients, activate RungeKuttaOntology."
 E2 = "Identify the Butcher tableau and method order before reasoning about execution."
 E3 = "For explicit methods, compute stages in dependency order."
 E4 = "For implicit methods, configure nonlinear and linear subsolvers for stage equations."
 E5 = "For adaptive embedded methods, compare paired solutions and apply explicit step acceptance and rejection logic."
 E6 = "For stiff systems, assess A-stability, L-stability or related stiff-solver properties."
 E7 = "For monotonicity-sensitive problems, assess SSP properties."
 E8 = "For geometric long-time problems, consider symplectic or partitioned Runge-Kutta methods."
 E9 = "Validate through order tests, stability analysis, stage residuals, reference solutions and reproducibility."
}

RECURSION {
 ENTRY = RungeKuttaMethod
 EXPAND(RungeKuttaMethod) -> [
  RungeKuttaSolver,RKMethod,OneStepMethod,MultiStageMethod,Stage,
  StageDerivative,ButcherTableau,ButcherMatrix,WeightVector,StageAbscissa,
  ExplicitRungeKutta,ImplicitRungeKutta,DIRK,SDIRK,
  FullyImplicitRungeKutta,CollocationMethod,GaussLegendreRungeKutta,
  RadauRungeKutta,LobattoRungeKutta,StifflyAccurateRungeKutta,
  ClassicalRK4,RK4,RK3,RK2,MidpointMethod,HeunMethod,RalstonMethod,
  EmbeddedRungeKutta,EmbeddedPair,RungeKuttaFehlberg,RKF45,
  DormandPrince,CashKarp,BogackiShampine,LocalErrorEstimate,
  AdaptiveStepSize,StepSizeController,DenseOutput,ContinuousExtension,
  OrderCondition,ButcherTree,RootedTree,OrderOfAccuracy,Consistency,
  Convergence,Stability,AbsoluteStability,StabilityRegion,StabilityFunction,
  AStability,LStability,AlgebraicStability,SSPRungeKutta,Monotonicity,
  SymplecticRungeKutta,PartitionedRungeKutta,IMEXRungeKutta,
  AdditiveRungeKutta,StiffEquation,Stiffness,Jacobian,
  NonlinearStageSystem,NonlinearSolver,NewtonMethod,LinearSolver,
  Preconditioner,StageResidual,FunctionEvaluationCount,
  JacobianEvaluationCount,FloatingPointArithmetic,MachinePrecision,
  RoundOffError,Verification,ReferenceSolution,ManufacturedSolution,
  BenchmarkProblem,Reproducibility
 ]
 EXPAND(RungeKuttaFamilies) -> [
  ExplicitRungeKuttaMethods,
  EmbeddedAdaptiveRungeKuttaMethods,
  ImplicitRungeKuttaMethods,
  DIRKAndSDIRKMethods,
  CollocationRungeKuttaMethods,
  SSPRungeKuttaMethods,
  SymplecticAndPartitionedRungeKutta,
  IMEXAndAdditiveRungeKutta
 ]
 STOP_CONDITION = "Stop when tableau, stages, order, adaptivity, stability, stiffness, subsolvers and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Ordinary Differential Equation Solver Ontology"
 RELATED_ONTOLOGIES = [
  "Ordinary Differential Equation Solver Ontology",
  "Differential Equation Solver Ontology",
  "Euler Method Ontology",
  "Partial Differential Equation Solver Ontology",
  "Linear Solver Ontology",
  "Nonlinear Solver Ontology",
  "Newton-Raphson Ontology",
  "Numerical Analysis Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology"
 ]
 ROUTE_RULES = [
  "Runge-Kutta -> ODE Solver for parent time-integration semantics",
  "Runge-Kutta -> Euler Method for first-order RK relationship",
  "Runge-Kutta -> PDE Solver when used after method-of-lines discretisation",
  "Runge-Kutta -> Nonlinear Solver for implicit stage equations",
  "Runge-Kutta -> Linear Solver for Newton stage corrections",
  "Runge-Kutta -> Numerical Analysis for order, consistency, stability and convergence",
  "Runge-Kutta -> Numerical Error for local and global error semantics",
  "Runge-Kutta -> Numerical Stability for absolute-stability behaviour",
  "Runge-Kutta -> Floating Point Arithmetic for high-stage and small-step round-off effects"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible Runge-Kutta families, tableaux or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve explicit-versus-implicit Runge-Kutta distinction.",
  "Preserve stage-coefficient-versus-solution-state distinction.",
  "Preserve formal-order-versus-stability distinction.",
  "Preserve embedded-pair-versus-single-formula distinction.",
  "Preserve local-error-estimate-versus-global-error distinction.",
  "Preserve stiff-versus-nonstiff suitability distinction.",
  "Preserve algebraic-stage-solve-versus-time-integration distinction.",
  "Preserve machine-readable Runge-Kutta semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "A Runge-Kutta method advances an ODE solution using multiple internal stage evaluations combined through Butcher coefficients."
 EXPLICIT_SUMMARY = "Explicit Runge-Kutta methods compute stages sequentially and avoid nonlinear stage solves."
 IMPLICIT_SUMMARY = "Implicit Runge-Kutta methods solve coupled or diagonally implicit stage equations and can provide strong stability for stiff problems."
 ADAPTIVE_SUMMARY = "Embedded Runge-Kutta pairs estimate local error from shared stages and support adaptive step-size control."
 ORDER_SUMMARY = "Method order is determined by algebraic conditions on the Butcher tableau."
 STABILITY_SUMMARY = "The stability function determines absolute-stability behaviour on the linear test equation."
 VALIDATION_SUMMARY = "Runge-Kutta results should be checked through tableau verification, order tests, stability analysis, stage residuals, reference solutions and reproducibility."
}

FLOW {
 INPUT
 -> detect_Runge_Kutta_context
 -> identify_ODE_system_stiffness_accuracy_goal_cost_and_event_requirements
 -> select_explicit_embedded_DIRK_SDIRK_fully_implicit_collocation_SSP_symplectic_or_IMEX_family
 -> load_or_define_Butcher_tableau
 -> compute_stage_values_sequentially_or_with_stage_subsolvers
 -> combine_stage_derivatives_into_candidate_solution
 -> if_embedded_estimate_local_error_and_accept_or_reject_step
 -> analyse_order_conditions_stability_function_and_stiffness_properties
 -> if_required_construct_dense_output
 -> assess_function_evaluation_cost_stage_residuals_roundoff_and_memory
 -> validate_against_reference_solution_and_step_refinement
 -> route_to_related_ODE_Euler_PDE_linear_nonlinear_analysis_error_stability_convergence_and_floating_point_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Runge-Kutta Ontology defines multi-stage one-step numerical integration for ODEs. It supports Butcher tableaux, stage equations and derivatives, explicit RK2, RK3 and classical RK4 methods, embedded pairs such as RKF45, Dormand-Prince, Cash-Karp and Bogacki-Shampine, adaptive step-size control, implicit RK, DIRK, SDIRK, Radau, Gauss and Lobatto collocation methods, order conditions and rooted-tree relationships, stability functions, A-stability and L-stability, SSP, symplectic, partitioned, IMEX and additive Runge-Kutta methods, nonlinear stage systems, Jacobians and subsolvers, dense output, finite precision, verification, benchmarking and reproducibility."
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-COMPUTATIONAL-MATHEMATICS-RUNGE-KUTTA-ONTOLOGY-V1"
}

}

END_FLOW