Equation Solver Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Equation Solver Ontology within the Kireth Research Semantic Library. An equation solver is a computational method or system for determining unknown quantities that satisfy mathematical equations. This ontology supports symbolic and numerical solvers, direct and iterative methods, scalar and system equations, linear and nonlinear problems, root finding, solver configuration, initialisation, convergence, stopping criteria, residuals, conditioning, error control, verification and solver selection.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = EquationSolver
 ENTITY_CLASS = ComputationalEquationResolutionFramework
 PRIMARY_CONTEXT = SolvingEquations
 DEFINITION = "An equation solver is an algorithmic or symbolic procedure that determines exact or approximate values satisfying one or more mathematical equations subject to declared domains, constraints and tolerances."
 SYMBOLIC_FORMS = [
  "solve(f(x)=0)",
  "solve(A*x=b)",
  "solve(F(x)=0)",
  "x_star=Solver(problem,options)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for solver classification, method selection, configuration, initialisation, convergence, residuals, error control, conditioning, verification and reproducible equation solution."
}

SCOPE {
 INCLUDE = [
  EquationSolver, Solver, SolverAlgorithm, SolverMethod, SolverConfiguration,
  SolverOption, SolverParameter, SolverState, SolverStatus, SolverResult,
  Equation, Unknown, Variable, Parameter, Constraint, Domain, Solution,
  SolutionSet, ExactSolution, ApproximateSolution, NumericalSolution,
  SymbolicSolution, LinearEquationSolver, NonlinearEquationSolver,
  ScalarEquationSolver, SystemEquationSolver, PolynomialSolver,
  RootSolver, RootFindingSolver, LinearSystemSolver, NonlinearSystemSolver,
  SymbolicSolver, NumericalSolver, DirectSolver, IterativeSolver,
  BracketingSolver, OpenSolver, HybridSolver, BisectionSolver,
  RegulaFalsiSolver, SecantSolver, NewtonSolver, NewtonRaphsonSolver,
  ModifiedNewtonSolver, FixedPointSolver, SteffensenSolver, BrentSolver,
  GaussianEliminationSolver, LUSolver, QRSolver, CholeskySolver,
  JacobiSolver, GaussSeidelSolver, SORSolver, ConjugateGradientSolver,
  GMRESSolver, BiCGSTABSolver, KrylovSolver, MultigridSolver,
  PreconditionedSolver, LeastSquaresSolver, MinimumNormSolver,
  Jacobian, Derivative, Gradient, Hessian, Residual, ResidualNorm,
  ForwardError, BackwardError, AbsoluteError, RelativeError,
  TruncationError, RoundOffError, AbsoluteTolerance, RelativeTolerance,
  ResidualTolerance, StepTolerance, FunctionTolerance, StoppingCriterion,
  MaximumIterations, MaximumEvaluations, Convergence, ConvergenceRate,
  LinearConvergence, SuperlinearConvergence, QuadraticConvergence,
  Divergence, Stagnation, Breakdown, Failure, Success, Warning,
  InitialGuess, InitialBracket, InitialVector, Scaling, Equilibration,
  Preconditioner, LineSearch, Damping, TrustRegion, StepControl,
  ContinuationMethod, HomotopyMethod, BasinOfAttraction, MultipleRoot,
  RepeatedRoot, SingularJacobian, IllConditionedSystem, ConditionNumber,
  Conditioning, Sensitivity, NumericalStability, FloatingPointArithmetic,
  MachinePrecision, SolverRobustness, SolverEfficiency,
  ComputationalComplexity, MemoryComplexity, Verification,
  SubstitutionCheck, ReferenceSolution, Benchmarking, Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  OptimiserWithoutEquationSolvingSemantics,
  PureExpressionEvaluatorWithoutUnknownResolution,
  SymbolicSimplifierWithoutSolutionSearch,
  StatisticalEstimatorWithoutEquationSolverContext
 ]
 DISAMBIGUATION_RULE = "When an algorithm, method or software procedure is used to determine values satisfying equations, interpret the context as an equation solver."
}

CORE_CONCEPTS {
 EquationSolver = "Procedure for computing values satisfying mathematical equations."
 SolverConfiguration = "Collection of method choices, tolerances, initialisation and execution parameters controlling a solver."
 DirectSolver = "Solver using a prescribed finite sequence of operations without iterative convergence as its primary mechanism."
 IterativeSolver = "Solver generating successive approximations until a convergence or stopping condition is met."
 BracketingSolver = "Scalar root solver preserving an interval containing a root under suitable assumptions."
 NewtonSolver = "Derivative-based iterative solver using local linearisation."
 LinearSystemSolver = "Solver for equations represented as A*x=b."
 NonlinearSystemSolver = "Solver for coupled nonlinear equations F(x)=0."
 SolverStatus = "Structured outcome describing success, failure, convergence or termination reason."
}

RELATIONS {
 EquationSolver --is_child_of--> SolvingEquations
 EquationSolver --solves--> Equation
 EquationSolver --produces--> SolverResult
 SolverResult --contains--> Solution
 SolverConfiguration --controls--> EquationSolver
 IterativeSolver --uses--> StoppingCriterion
 BracketingSolver --uses--> InitialBracket
 OpenSolver --uses--> InitialGuess
 NewtonSolver --uses--> Derivative
 NonlinearSystemSolver --uses--> Jacobian
 LinearSystemSolver --may_use--> MatrixFactorisation
 KrylovSolver --uses--> Preconditioner
 SolverStatus --describes--> SolverTermination
 Residual --measures--> EquationMismatch
 Conditioning --influences--> SolutionSensitivity
 NumericalStability --influences--> SolverAccuracy
 Verification --checks--> SolverResult
 Benchmarking --compares--> SolverPerformance
}

OPERATORS {
 SOLVE(problem,options) := solver_result
 SCALAR_ROOT(f,x) := f(x)=0
 LINEAR_SOLVE(A,b) := find_x_such_that_A*x=b
 NONLINEAR_SOLVE(F,x) := find_x_such_that_F(x)=0
 RESIDUAL(problem,x) := evaluate_equation_mismatch(problem,x)
 CONVERGED(r,dx,opts) := stopping_conditions_satisfied(r,dx,opts)
 NEWTON_STEP(x,f) := x_next=x-f(x)/f_prime(x)
 NEWTON_SYSTEM_STEP(x,F,J) := solve(J(x)*delta=-F(x)); x_next=x+delta
 PRECONDITIONED_LINEAR_SYSTEM(M,A,x,b) := M^(-1)*A*x=M^(-1)*b
}

AXIOMS {
 A1 = "A solver must be interpreted relative to the class of equations it is designed to solve."
 A2 = "Solver success and mathematical existence of a solution are distinct."
 A3 = "Residual size and solution error are distinct."
 A4 = "Iterative solver behaviour depends on initialisation, tolerances and problem structure."
 A5 = "Direct and iterative solvers have different convergence and error semantics."
 A6 = "Conditioning belongs to the mathematical problem; stability belongs to the solver algorithm."
 A7 = "Stopping conditions must be explicit and scale appropriate."
 A8 = "Solver outputs require verification against the original equation and constraints."
}

REASONING {
 R1_CONTEXT = identify(equation_type,unknowns,domain,constraints,accuracy_goal)
 R2_SOLVER_CLASS = classify(symbolic,numerical,direct,iterative,scalar,system,linear_or_nonlinear)
 R3_STRUCTURE = inspect(linearity,sparsity,symmetry,derivatives,conditioning,multiplicity)
 R4_METHOD_SELECTION = choose(method_appropriate_to_problem_and_accuracy)
 R5_CONFIGURATION = set(initial_guess,bracket,tolerances,max_iterations,scaling,preconditioner)
 R6_EXECUTION = run_solver_and_track_state)
 R7_CONVERGENCE = monitor(residual,step,rate,stagnation,breakdown)
 R8_ERROR = assess(forward_error,backward_error,conditioning,roundoff,truncation)
 R9_STATUS = classify(success,failure,warning_or_termination_reason)
 R10_VERIFY = substitute_solution_and_check_domain_constraints_and_reproducibility)
}

CONSTRAINTS {
 C1 = "A solver can terminate successfully without guaranteeing uniqueness."
 C2 = "A solver can fail even when a mathematical solution exists."
 C3 = "A small residual can coexist with a large forward error in ill-conditioned problems."
 C4 = "Newton-type solvers can diverge from poor initial guesses."
 C5 = "Bracketing solvers require valid bracketing assumptions for standard guarantees."
 C6 = "Iterative stopping thresholds below machine precision can cause stagnation."
 C7 = "Preconditioning changes solver behaviour without changing the intended exact solution when applied consistently."
 C8 = "Maximum-iteration termination is not equivalent to convergence."
 C9 = "Transformation or scaling can alter numerical behaviour and must preserve original equation semantics."
 C10 = "Solver verification must use the original equation, not only internal transformed systems."
}

SEMANTIC_EQUIVALENCE {
 "EquationSolver" <=> "EquationSolvingAlgorithm"
 "NewtonRaphsonSolver" <=> "NewtonSolver"
 "RootFindingSolver" <=> "RootSolver"
 "LinearSystemSolver" <=> "LinearEquationSystemSolver"
 "IterativeSolver" <=> "IterativeEquationSolver"
}

VALIDATION {
 V1 = "Supported equation class is explicit."
 V2 = "Domain and constraints are explicit."
 V3 = "Solver method and configuration are documented."
 V4 = "Initial guesses or brackets are documented."
 V5 = "Stopping criteria and tolerances are documented."
 V6 = "Termination status is reported."
 V7 = "Residuals are evaluated using the original equation."
 V8 = "Conditioning is considered for sensitive problems."
 V9 = "Candidate solutions satisfy original constraints and domain."
 V10 = "Results are reproducible under documented arithmetic and solver settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 EQUATION_SOLVER_DEFINITION = 0.99
 METHOD_SELECTION_REASONING = 0.99
 CONVERGENCE_REASONING = 0.99
 LINEAR_SOLVER_REASONING = 0.99
 NONLINEAR_SOLVER_REASONING = 0.98
 STATUS_REASONING = 0.99
 VERIFICATION_REASONING = 0.99
 POLICY = "Reduce confidence when equation class, domain, initialisation, tolerances, conditioning, derivative information or termination status are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, EquationSolverReasoning,
  SolverSelectionReasoning, SolverConfigurationReasoning,
  RootSolverReasoning, LinearSystemSolverReasoning,
  NonlinearSystemSolverReasoning, DirectSolverReasoning,
  IterativeSolverReasoning, ConvergenceReasoning,
  StoppingCriterionReasoning, ResidualReasoning,
  ConditioningReasoning, NumericalStabilityReasoning,
  SolverStatusReasoning, VerificationReasoning,
  KnowledgeGraphConstruction, RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "equation solver" -> EquationSolver
  "solver" -> EquationSolver
  "root solver" -> RootSolver
  "Newton-Raphson solver" -> NewtonSolver
  "linear system solver" -> LinearSystemSolver
  "iterative equation solver" -> IterativeSolver
 }
}

EXECUTION_RULES {
 E1 = "If an algorithm or procedure computes values satisfying equations, activate EquationSolverOntology."
 E2 = "Classify the equation and solver family before selecting parameters."
 E3 = "For iterative solvers, define explicit stopping criteria before execution."
 E4 = "For Newton-type solvers, provide derivative or Jacobian semantics and suitable initialisation."
 E5 = "For linear systems, exploit matrix structure, sparsity and conditioning."
 E6 = "For large sparse linear systems, consider Krylov methods with preconditioning."
 E7 = "If convergence stagnates, inspect scaling, conditioning, machine precision and method suitability."
 E8 = "Report solver termination status distinctly from mathematical solution validity."
 E9 = "Verify all returned solutions against the original equation, domain and constraints."
}

RECURSION {
 ENTRY = EquationSolver
 EXPAND(EquationSolver) -> [
  SolverAlgorithm, SolverMethod, SolverConfiguration, SolverOption,
  SolverParameter, SolverState, SolverStatus, SolverResult, Equation,
  Solution, ExactSolution, ApproximateSolution, LinearEquationSolver,
  NonlinearEquationSolver, ScalarEquationSolver, SystemEquationSolver,
  PolynomialSolver, RootSolver, LinearSystemSolver,
  NonlinearSystemSolver, SymbolicSolver, NumericalSolver, DirectSolver,
  IterativeSolver, BracketingSolver, OpenSolver, HybridSolver,
  BisectionSolver, RegulaFalsiSolver, SecantSolver, NewtonSolver,
  ModifiedNewtonSolver, FixedPointSolver, BrentSolver,
  GaussianEliminationSolver, LUSolver, QRSolver, CholeskySolver,
  JacobiSolver, GaussSeidelSolver, SORSolver,
  ConjugateGradientSolver, GMRESSolver, BiCGSTABSolver, KrylovSolver,
  MultigridSolver, PreconditionedSolver, LeastSquaresSolver,
  Jacobian, Residual, ResidualNorm, ForwardError, BackwardError,
  AbsoluteTolerance, RelativeTolerance, ResidualTolerance,
  StepTolerance, StoppingCriterion, MaximumIterations, Convergence,
  Divergence, Stagnation, Breakdown, Success, Failure, Warning,
  InitialGuess, InitialBracket, Scaling, Preconditioner, LineSearch,
  Damping, TrustRegion, ContinuationMethod, BasinOfAttraction,
  MultipleRoot, SingularJacobian, IllConditionedSystem, Conditioning,
  NumericalStability, MachinePrecision, Verification, Benchmarking,
  Reproducibility
 ]
 EXPAND(SolverFamilies) -> [
  SymbolicSolvers,
  ScalarRootSolvers,
  LinearSystemSolvers,
  NonlinearSystemSolvers,
  DirectSolvers,
  IterativeSolvers,
  HybridSolvers,
  SolverVerification
 ]
 STOP_CONDITION = "Stop when equation class, solver family, configuration, convergence, error, status and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Solving Equations"
 RELATED_ONTOLOGIES = [
  "Solving Equations",
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Machine Precision Ontology"
 ]
 ROUTE_RULES = [
  "Equation Solver -> Solving Equations for parent semantics",
  "Equation Solver -> Numerical Methods for solver algorithms",
  "Equation Solver -> Numerical Linear Algebra for matrix-system solvers",
  "Equation Solver -> Numerical Analysis for convergence and conditioning",
  "Equation Solver -> Numerical Error for residual and solution-error semantics",
  "Equation Solver -> Numerical Stability for algorithmic robustness",
  "Equation Solver -> Numerical Convergence for iterative stopping behaviour",
  "Equation Solver -> Floating Point Arithmetic for finite-precision effects"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible solver classes, configurations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve solver-versus-equation distinction.",
  "Preserve direct-versus-iterative solver distinction.",
  "Preserve symbolic-versus-numerical solver distinction.",
  "Preserve solver-status-versus-solution-validity distinction.",
  "Preserve residual-versus-solution-error distinction.",
  "Preserve configuration-versus-algorithm distinction.",
  "Preserve transformed-problem-versus-original-problem distinction.",
  "Preserve machine-readable equation-solver semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "An equation solver is a symbolic or numerical procedure for determining values satisfying one or more equations."
 CLASSIFICATION_SUMMARY = "Solvers are classified by equation type, symbolic or numerical approach, and direct, iterative, bracketing, open or hybrid behaviour."
 CONFIGURATION_SUMMARY = "Initialisation, tolerances, scaling, preconditioning and iteration limits define solver execution semantics."
 CONVERGENCE_SUMMARY = "Iterative solvers require explicit residual, step, convergence and stagnation monitoring."
 STATUS_SUMMARY = "Solver success, warning, failure and termination reason must be represented separately from mathematical validity."
 ERROR_SUMMARY = "Residual, forward error, backward error, conditioning and finite precision provide complementary measures of solver quality."
 VERIFICATION_SUMMARY = "Solver outputs must be checked against the original equations, domains and constraints."
}

FLOW {
 INPUT
 -> detect_equation_solver_context
 -> identify_equation_type_unknowns_domain_constraints_and_accuracy_goal
 -> classify_symbolic_numerical_direct_iterative_scalar_system_linear_or_nonlinear_solver
 -> inspect_problem_structure_conditioning_derivatives_and_sparsity
 -> select_solver_method
 -> configure_initialisation_tolerances_iteration_limits_scaling_and_preconditioner
 -> execute_solver_and_track_state
 -> monitor_residual_step_convergence_rate_stagnation_and_breakdown
 -> assess_forward_backward_roundoff_and_truncation_error
 -> classify_termination_status
 -> verify_candidate_solution_against_original_equation_domain_and_constraints
 -> route_to_related_solving_equations_and_numerical_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Equation Solver Ontology defines computational procedures for solving mathematical equations. It supports symbolic and numerical solvers, scalar and system equations, linear and nonlinear problems, direct, iterative, bracketing, open and hybrid methods, bisection, false position, secant, Newton, fixed-point and Brent solvers, Gaussian elimination, LU, QR and Cholesky solvers, Jacobi, Gauss-Seidel, SOR, conjugate-gradient, GMRES and BiCGSTAB methods, preconditioning, solver configuration, initial guesses and brackets, tolerances, stopping criteria, convergence, stagnation and failure states, residual and error analysis, conditioning, numerical stability, machine precision, verification, benchmarking and reproducibility."
}

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

}

END_FLOW