Euler Method Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Euler Method Ontology within the Kireth Research Semantic Library. The Euler method is a first-order numerical time-integration method for ordinary differential equations, including explicit forward Euler and implicit backward Euler.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = EulerMethod
 ENTITY_CLASS = FirstOrderTimeIntegrationFramework
 PRIMARY_CONTEXT = OrdinaryDifferentialEquationSolver
 DEFINITION = "The Euler method is a first-order numerical method for advancing an ODE solution using a local derivative approximation over a finite step."
 SYMBOLIC_FORMS = ["y_(n+1)=y_n+h*f(t_n,y_n)","y_(n+1)=y_n+h*f(t_(n+1),y_(n+1))","global_error=O(h)"]
}

SCOPE {
 INCLUDE = [EulerMethod,EulerSolver,ForwardEuler,ExplicitEuler,BackwardEuler,ImplicitEuler,ODE,ODESystem,InitialValueProblem,InitialCondition,TimeIntegrator,OneStepMethod,ExplicitMethod,ImplicitMethod,FixedStepMethod,VariableStepMethod,TimeStep,StepSize,Derivative,VectorField,TangentApproximation,LocalTruncationError,GlobalError,DiscretisationError,FirstOrderAccuracy,Consistency,Stability,Convergence,AbsoluteStability,StabilityRegion,StabilityFunction,DahlquistTestEquation,AmplificationFactor,StiffEquation,Stiffness,AStability,LStability,StepSizeRestriction,NonlinearSolver,NewtonMethod,FixedPointIteration,LinearSolver,Jacobian,Residual,SolverTolerance,StepDoubling,RichardsonExtrapolation,ImprovedEuler,HeunMethod,RungeKuttaMethod,NumericalDamping,PhaseError,LongTimeIntegration,FloatingPointArithmetic,MachinePrecision,RoundOffError,FunctionEvaluation,Verification,ReferenceSolution,ManufacturedSolution,Reproducibility]
 EXCLUDE_AS_PRIMARY = [RungeKuttaMethodBeyondEulerSpecialCase,MultistepMethodWithoutEulerSemantics,SymbolicODESolutionWithoutNumericalStepping]
 DISAMBIGUATION_RULE = "When an ODE state is advanced over one step using a first-order Euler discretisation, interpret the context as the Euler method."
}

CORE_CONCEPTS {
 EulerMethod = "First-order one-step numerical integration method."
 ForwardEuler = "Explicit update using the derivative at the current state."
 BackwardEuler = "Implicit update using the derivative at the next state."
 FirstOrderAccuracy = "Global error proportional to step size under suitable regularity."
 StabilityRegion = "Set of scaled eigenvalues for which the numerical recurrence is stable."
 AmplificationFactor = "Factor mapping one numerical solution value or perturbation to the next for a linear test problem."
}

RELATIONS {
 EulerMethod --is_child_of--> OrdinaryDifferentialEquationSolver
 ForwardEuler --is_type_of--> ExplicitMethod
 BackwardEuler --is_type_of--> ImplicitMethod
 EulerMethod --is_type_of--> OneStepMethod
 BackwardEuler --often_requires--> NonlinearSolver
 EulerMethod --has_global_order--> FirstOrderAccuracy
 StepSize --influences--> TruncationError
 StepSize --influences--> Stability
 StiffEquation --can_restrict--> ForwardEuler
 BackwardEuler --is--> AStableMethod
 BackwardEuler --is--> LStableMethod
 StepDoubling --can_estimate--> EulerError
}

OPERATORS {
 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)))
 FORWARD_EULER_STABILITY(z) := R(z)=1+z
 BACKWARD_EULER_STABILITY(z) := R(z)=1/(1-z)
 ODE_RESIDUAL(y_dot,f,t,y) := y_dot-f(t,y)
}
AXIOMS {
 A1 = "Forward Euler evaluates the vector field at the beginning of the step."
 A2 = "Backward Euler evaluates the vector field at the end of the step and is implicit."
 A3 = "Euler methods are globally first-order accurate under suitable smoothness and stability assumptions."
 A4 = "Local truncation error and accumulated global error are distinct."
 A5 = "Forward Euler has a bounded absolute-stability region."
 A6 = "Backward Euler is A-stable and L-stable in standard linear stability analysis."
 A7 = "Reducing step size generally reduces discretisation error but increases computational work."
 A8 = "Euler results require explicit step-size, stability, error and verification semantics."
}

REASONING {
 R1_CONTEXT = identify(ODE_system,initial_condition,time_interval,stiffness,accuracy_goal)
 R2_VARIANT = select(forward_Euler_or_backward_Euler)
 R3_STEP = choose(step_size_from_accuracy_stability_and_cost)
 R4_FORWARD = if_explicit evaluate_f_at_current_state_and_advance
 R5_BACKWARD = if_implicit form_next_state_equation_and_solve
 R6_ERROR = estimate(local_and_global_discretisation_error)
 R7_STABILITY = analyse(amplification_factor,eigenvalues,stiffness_and_step_restriction)
 R8_ADAPTIVITY = if_variable_step use_step_doubling_or_external_error_estimator
 R9_PRECISION = assess(roundoff,accumulation,overflow_and_underflow)
 R10_VALIDATE = compare(reference_solution,analytic_solution,step_refinement_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Forward Euler can be unstable outside its absolute-stability region."
 C2 = "Forward Euler can require impractically small steps for stiff systems."
 C3 = "Backward Euler requires an algebraic solve at each step for nonlinear problems."
 C4 = "First-order accuracy can require very small steps for high-accuracy demands."
 C5 = "A stable step size does not necessarily guarantee adequate accuracy."
 C6 = "A small implicit algebraic residual does not guarantee small time-discretisation error."
 C7 = "Nonsmooth forcing can reduce expected error behaviour."
 C8 = "Very small steps can increase accumulated floating-point work and round-off effects."
 C9 = "Long-time Euler integration can introduce phase or damping error."
 C10 = "Euler's simplicity does not imply universal suitability."
}

SEMANTIC_EQUIVALENCE {
 "EulerMethod" <=> "EulerIntegration"
 "ForwardEuler" <=> "ExplicitEuler"
 "BackwardEuler" <=> "ImplicitEuler"
 "FirstOrderAccuracy" <=> "OrderOneGlobalAccuracy"
}

VALIDATION {
 V1 = "ODE system and initial condition are explicit."
 V2 = "Forward or backward Euler variant is documented."
 V3 = "Step size and time interval are documented."
 V4 = "Stability restrictions are assessed for forward Euler."
 V5 = "Implicit-solver tolerances are documented for backward Euler."
 V6 = "Convergence under step refinement is checked where feasible."
 V7 = "Observed order is compared with first-order expectations."
 V8 = "Stiffness is considered when method suitability is assessed."
 V9 = "Analytic, manufactured or reference solutions are used where feasible."
 V10 = "Results are reproducible under documented arithmetic and solver settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 EULER_METHOD_DEFINITION = 0.99
 FORWARD_EULER_REASONING = 0.99
 BACKWARD_EULER_REASONING = 0.99
 FIRST_ORDER_REASONING = 0.99
 STABILITY_REASONING = 0.99
 STIFFNESS_REASONING = 0.98
 POLICY = "Reduce confidence when Euler variant, step size, stiffness, stability spectrum, implicit-solver tolerance or arithmetic precision are underspecified."
}
AI_CONSUMPTION {
 PURPOSES = [SemanticSearch,OntologyGrounding,EulerMethodReasoning,ForwardEulerReasoning,BackwardEulerReasoning,OneStepMethodReasoning,FirstOrderAccuracyReasoning,LocalTruncationErrorReasoning,GlobalErrorReasoning,AbsoluteStabilityReasoning,AmplificationFactorReasoning,StiffnessReasoning,ImplicitSubsolverReasoning,StepSizeReasoning,StepDoublingReasoning,FloatingPointReasoning,VerificationReasoning,KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference]
 NORMALISE = ["Euler method -> EulerMethod","forward Euler -> ForwardEuler","explicit Euler -> ForwardEuler","backward Euler -> BackwardEuler","implicit Euler -> BackwardEuler"]
}

EXECUTION_RULES {
 E1 = "If an ODE is advanced with a first-order Euler discretisation, activate EulerMethodOntology."
 E2 = "Distinguish forward Euler from backward Euler before stability reasoning."
 E3 = "For forward Euler, choose step size according to accuracy and stability."
 E4 = "For backward Euler, configure the required algebraic solve."
 E5 = "For stiff systems, consider backward Euler when its damping properties are appropriate."
 E6 = "Use step refinement to confirm first-order global convergence."
 E7 = "If adaptive behaviour is required, use step doubling or suitable error control."
 E8 = "Monitor finite-precision accumulation for long integrations."
 E9 = "Validate against analytic, manufactured or reference solutions."
}

RECURSION {
 ENTRY = EulerMethod
 EXPAND(EulerMethod) -> [EulerSolver,ForwardEuler,BackwardEuler,ODE,InitialValueProblem,InitialCondition,TimeIntegrator,OneStepMethod,ExplicitMethod,ImplicitMethod,TimeStep,StepSize,Derivative,VectorField,LocalTruncationError,GlobalError,FirstOrderAccuracy,Consistency,Stability,Convergence,AbsoluteStability,StabilityRegion,DahlquistTestEquation,AmplificationFactor,StiffEquation,Stiffness,AStability,LStability,StepSizeRestriction,NonlinearSolver,NewtonMethod,FixedPointIteration,LinearSolver,Residual,StepDoubling,RichardsonExtrapolation,RungeKuttaMethod,NumericalDamping,PhaseError,FloatingPointArithmetic,MachinePrecision,RoundOffError,Verification,ReferenceSolution,Reproducibility]
 STOP_CONDITION = "Stop when Euler variant, ODE context, step size, error, stability, stiffness, implicit solve and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Ordinary Differential Equation Solver Ontology"
 RELATED_ONTOLOGIES = ["Ordinary Differential Equation Solver Ontology","Differential Equation Solver Ontology","Partial Differential Equation Solver Ontology","Numerical Differentiation Ontology 2","Linear Solver Ontology","Nonlinear Solver Ontology","Fixed-Point Iteration Ontology","Newton-Raphson Ontology","Numerical Analysis Ontology 2","Numerical Error Ontology","Numerical Stability Ontology 2","Numerical Convergence Ontology","Floating Point Arithmetic Ontology"]
 ROUTE_RULES = ["Euler Method -> ODE Solver for parent semantics","Euler Method -> PDE Solver when used as PDE time discretisation","Euler Method -> Nonlinear Solver for backward-Euler equations","Euler Method -> Linear Solver for linear backward-Euler systems","Euler Method -> Numerical Analysis for consistency stability and convergence","Euler Method -> Numerical Error for local and global error"]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible Euler variants or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = ["Preserve forward-versus-backward distinction.","Preserve explicit-versus-implicit distinction.","Preserve local-versus-global error distinction.","Preserve accuracy-versus-stability distinction.","Preserve stiff-versus-nonstiff suitability distinction.","Preserve time-discretisation-versus-algebraic-subsolve distinction.","Preserve machine-readable Euler semantics."]
}

OUTPUT {
 CANONICAL_DEFINITION = "The Euler method is a first-order one-step numerical method for advancing ODE solutions."
 FORWARD_SUMMARY = "Forward Euler advances explicitly using the derivative at the current state."
 BACKWARD_SUMMARY = "Backward Euler advances implicitly using the derivative at the next state."
 ERROR_SUMMARY = "Euler methods are globally first-order accurate under suitable regularity and stability assumptions."
 STABILITY_SUMMARY = "Forward Euler has a bounded stability region, while backward Euler is A-stable and L-stable in standard linear analysis."
 VALIDATION_SUMMARY = "Euler results should be checked through step refinement, stability analysis, implicit-solver accuracy, reference solutions and reproducibility."
}

FLOW {
 INPUT
 -> detect_Euler_method_context
 -> identify_ODE_system_initial_condition_time_interval_stiffness_and_accuracy_goal
 -> select_forward_or_backward_Euler
 -> choose_step_size_from_accuracy_stability_and_cost
 -> if_forward_evaluate_current_derivative_and_advance
 -> if_backward_form_implicit_next_state_equation_and_solve
 -> estimate_local_and_global_error
 -> analyse_amplification_factor_stability_region_and_stiffness
 -> if_needed_apply_step_refinement_or_step_doubling
 -> assess_roundoff_accumulation_and_long_time_error
 -> validate_against_reference_solution
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Euler Method Ontology defines first-order ODE integration through forward and backward Euler methods, including local and global error, first-order convergence, absolute stability, stiffness, implicit algebraic subsolvers, step refinement, finite precision and verification."
}

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

}

END_FLOW