Solving Equations

AI INTERPRETATION NOTE
This Flow Algebra defines the Solving Equations parent ontology within the Kireth Research Semantic Library. It provides computational semantics for finding values, vectors, functions or states satisfying mathematical equations, including linear and nonlinear equations, systems, root finding, iterative methods, direct methods, residuals, convergence, conditioning, numerical stability and verification.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = SolvingEquations
 ENTITY_CLASS = ComputationalEquationSolutionFramework
 PRIMARY_CONTEXT = ComputationalMathematicsOntologies
 DEFINITION = "Solving equations is the mathematical and computational process of determining unknown quantities that satisfy one or more equations subject to stated domains, constraints and tolerances."
 SYMBOLIC_FORMS = ["f(x)=0","A*x=b","F(x)=0","G(x)=x"]
 SEMANTIC_ROLE = "Provides machine-readable semantics for equation classification, exact and approximate solution, root finding, linear and nonlinear systems, iterative convergence, residuals, conditioning and solution verification."
}

SCOPE {
 INCLUDE = [
  Equation, EquationSolving, SolvingEquations, Unknown, Variable, Parameter,
  Solution, SolutionSet, Root, Zero, ExactSolution, ApproximateSolution,
  NumericalSolution, AnalyticalSolution, SymbolicSolution, LinearEquation,
  NonlinearEquation, PolynomialEquation, TranscendentalEquation,
  AlgebraicEquation, RationalEquation, ExponentialEquation,
  LogarithmicEquation, TrigonometricEquation, AbsoluteValueEquation,
  LinearSystem, NonlinearSystem, SimultaneousEquations, MatrixEquation,
  ScalarEquation, VectorEquation, RootFinding, BracketingMethod,
  OpenMethod, BisectionMethod, RegulaFalsi, FalsePositionMethod,
  SecantMethod, NewtonMethod, NewtonRaphsonMethod, ModifiedNewtonMethod,
  FixedPointIteration, SteffensenMethod, BrentMethod, HybridMethod,
  DirectMethod, IterativeMethod, GaussianElimination, LUDecomposition,
  QRDecomposition, CholeskyDecomposition, BackSubstitution,
  ForwardSubstitution, JacobiMethod, GaussSeidelMethod,
  SuccessiveOverRelaxation, ConjugateGradientMethod, GMRES,
  KrylovSubspaceMethod, Multigrid, Preconditioning, Jacobian,
  Derivative, Gradient, Hessian, Residual, ResidualNorm, Error,
  ForwardError, BackwardError, TruncationError, RoundOffError,
  AbsoluteTolerance, RelativeTolerance, StoppingCriterion, Convergence,
  ConvergenceRate, LinearConvergence, SuperlinearConvergence,
  QuadraticConvergence, Divergence, Stagnation, Conditioning,
  ConditionNumber, Sensitivity, NumericalStability, MachinePrecision,
  FloatingPointArithmetic, InitialGuess, InitialBracket, BasinOfAttraction,
  MultipleRoot, SimpleRoot, RepeatedRoot, SingularJacobian,
  IllConditionedSystem, OverdeterminedSystem, UnderdeterminedSystem,
  LeastSquaresSolution, MinimumNormSolution, Constraint, Domain,
  Existence, Uniqueness, Verification, SubstitutionCheck,
  IntervalCheck, ReferenceSolution, Benchmarking, Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  OptimisationWithoutEquationSolutionContext,
  PureExpressionSimplificationWithoutUnknownSolution,
  StatisticalEstimationWithoutEquationSemantics
 ]
 DISAMBIGUATION_RULE = "When the goal is to determine unknown quantities that satisfy one or more mathematical equalities, interpret the context as solving equations."
}

CORE_CONCEPTS {
 Equation = "Mathematical equality containing known and potentially unknown quantities."
 Solution = "Value, vector, function or state satisfying an equation under its declared domain."
 Root = "Value x satisfying f(x)=0."
 Residual = "Equation mismatch remaining at an approximate solution."
 DirectMethod = "Method intended to obtain a solution through a finite prescribed sequence of operations."
 IterativeMethod = "Method producing a sequence of approximations intended to converge to a solution."
 BracketingMethod = "Root-finding method maintaining an interval containing a root under suitable assumptions."
 NewtonMethod = "Derivative-based local iteration using linearisation."
 Conditioning = "Sensitivity of the solution to perturbations in problem data."
}

RELATIONS {
 SolvingEquations --is_child_of--> ComputationalMathematicsOntologies
 Equation --has--> Unknown
 Equation --has--> SolutionSet
 Root --satisfies--> ZeroEquation
 LinearSystem --is_represented_by--> MatrixEquation
 RootFinding --solves--> ScalarEquation
 NewtonMethod --uses--> Derivative
 NewtonMethodForSystems --uses--> Jacobian
 BisectionMethod --uses--> RootBracket
 FixedPointIteration --solves--> FixedPointEquation
 GaussianElimination --solves--> LinearSystem
 LUDecomposition --supports--> LinearSystemSolution
 IterativeMethod --produces--> ApproximationSequence
 Residual --measures--> EquationMismatch
 StoppingCriterion --uses--> ResidualOrStepMeasure
 Conditioning --controls--> PerturbationSensitivity
 NumericalStability --controls--> AlgorithmicErrorGrowth
 Verification --checks--> CandidateSolution
}

OPERATORS {
 ROOT_PROBLEM(f) := find_x_such_that_f(x)=0
 LINEAR_SYSTEM(A,x,b) := A*x=b
 NONLINEAR_SYSTEM(F,x) := F(x)=0
 RESIDUAL(f,x) := r=f(x)
 LINEAR_RESIDUAL(A,x,b) := r=b-A*x
 BISECTION(a,b) := c=(a+b)/2
 NEWTON(x,f) := x_next=x-f(x)/f_prime(x)
 SECANT(x0,x1,f) := x_next=x1-f(x1)*(x1-x0)/(f(x1)-f(x0))
 FIXED_POINT(x,g) := x_next=g(x)
 NEWTON_SYSTEM(x,F,J) := solve(J(x)*delta=-F(x)); x_next=x+delta
}

AXIOMS {
 A1 = "A candidate solution must satisfy the equation within exact or declared approximate semantics."
 A2 = "Existence and uniqueness are distinct properties."
 A3 = "Residual and solution error are distinct."
 A4 = "Iterative convergence depends on method, problem structure and initialisation."
 A5 = "Bracketing methods require suitable interval assumptions."
 A6 = "Newton-type methods require suitable local regularity and derivative information."
 A7 = "Problem conditioning and algorithmic stability are distinct."
 A8 = "Numerical solutions require explicit tolerances and verification."
}

REASONING {
 R1_CONTEXT = identify(equation_type,unknowns,domain,constraints,desired_accuracy)
 R2_CLASSIFY = classify(linear,nonlinear,scalar,system,polynomial,transcendental_or_other)
 R3_EXISTENCE = assess(existence_uniqueness_and_domain_conditions)
 R4_METHOD = select(symbolic,direct,bracketing,Newton,secant,fixed_point,Krylov_or_hybrid_method)
 R5_INITIALISE = determine(initial_guess,bracket,scaling_or_preconditioner)
 R6_ITERATE_OR_SOLVE = execute_selected_solution_process
 R7_CONVERGENCE = monitor(residual,step_size,convergence_rate_and_stagnation)
 R8_ERROR = assess(conditioning,forward_error,backward_error,roundoff_and_truncation)
 R9_VERIFY = substitute_solution_or_check_residual_and_constraints)
 R10_OUTPUT = report(solution,status,error_metrics,assumptions_and_confidence)
}

CONSTRAINTS {
 C1 = "An equation can have no solution, one solution or multiple solutions."
 C2 = "Squaring, division or other algebraic transformations can introduce or remove candidate solutions if domain restrictions are ignored."
 C3 = "Newton iteration can diverge or converge to an unintended root."
 C4 = "Bisection requires a valid sign-changing bracket for the standard continuous-root guarantee."
 C5 = "Repeated roots can reduce convergence rates of standard Newton iteration."
 C6 = "A small residual does not guarantee a small forward error for ill-conditioned problems."
 C7 = "Stopping tolerances below attainable numerical precision can cause stagnation."
 C8 = "Nonlinear systems can possess multiple basins of attraction."
 C9 = "Singular or nearly singular Jacobians can destabilise Newton steps."
 C10 = "Verification must respect the original equation and domain, not only transformed equations."
}

SEMANTIC_EQUIVALENCE {
 "EquationSolving" <=> "SolvingEquations"
 "RootFinding" <=> "ZeroFinding"
 "NewtonRaphsonMethod" <=> "NewtonMethod"
 "FalsePositionMethod" <=> "RegulaFalsi"
 "SimultaneousEquations" <=> "SystemOfEquations"
}

VALIDATION {
 V1 = "Original equation and domain are explicit."
 V2 = "Candidate solutions satisfy domain restrictions."
 V3 = "Residuals are evaluated using the original equation."
 V4 = "Extraneous solutions introduced by transformations are removed."
 V5 = "Iterative convergence criteria are documented."
 V6 = "Initial guesses or brackets are documented where relevant."
 V7 = "Conditioning is considered for sensitive problems."
 V8 = "Absolute and relative tolerances are scale appropriate."
 V9 = "Multiple solutions are considered where mathematically possible."
 V10 = "Results are reproducible under documented arithmetic and algorithm settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 EQUATION_SOLVING_DEFINITION = 0.99
 LINEAR_EQUATION_REASONING = 0.99
 ROOT_FINDING_REASONING = 0.99
 NONLINEAR_SYSTEM_REASONING = 0.98
 CONVERGENCE_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 VERIFICATION_REASONING = 0.99
 POLICY = "Reduce confidence when domain, initialisation, uniqueness, conditioning, stopping tolerance or numerical precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, EquationSolvingReasoning,
  RootFindingReasoning, LinearSystemReasoning, NonlinearEquationReasoning,
  NonlinearSystemReasoning, BisectionReasoning, NewtonMethodReasoning,
  SecantReasoning, FixedPointReasoning, IterativeSolverReasoning,
  ConvergenceReasoning, ResidualReasoning, ConditioningReasoning,
  NumericalStabilityReasoning, VerificationReasoning,
  KnowledgeGraphConstruction, RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "solving equations" -> SolvingEquations
  "equation solving" -> SolvingEquations
  "root finding" -> RootFinding
  "Newton-Raphson" -> NewtonMethod
  "false position" -> RegulaFalsi
  "simultaneous equations" -> SystemOfEquations
 }
}

EXECUTION_RULES {
 E1 = "If unknown quantities must satisfy mathematical equalities, activate SolvingEquations."
 E2 = "Classify the equation before selecting a solution method."
 E3 = "Preserve domain restrictions through algebraic transformations."
 E4 = "For bracketed scalar roots, use a bracketing method when reliability is prioritised."
 E5 = "For smooth local problems with good initialisation, consider Newton-type methods."
 E6 = "For linear systems, exploit matrix structure, sparsity and conditioning."
 E7 = "For nonlinear systems, analyse Jacobian structure and step acceptance."
 E8 = "For iterative methods, monitor residual, step size, stagnation and convergence."
 E9 = "Always verify candidate solutions against the original equation and constraints."
}

RECURSION {
 ENTRY = SolvingEquations
 EXPAND(SolvingEquations) -> [
  Equation, Solution, SolutionSet, Root, ExactSolution, ApproximateSolution,
  LinearEquation, NonlinearEquation, PolynomialEquation,
  TranscendentalEquation, LinearSystem, NonlinearSystem,
  SimultaneousEquations, MatrixEquation, RootFinding, BracketingMethod,
  BisectionMethod, RegulaFalsi, SecantMethod, NewtonMethod,
  FixedPointIteration, BrentMethod, HybridMethod, DirectMethod,
  IterativeMethod, GaussianElimination, LUDecomposition, QRDecomposition,
  CholeskyDecomposition, JacobiMethod, GaussSeidelMethod,
  ConjugateGradientMethod, GMRES, KrylovSubspaceMethod, Preconditioning,
  Jacobian, Derivative, Residual, ResidualNorm, ForwardError,
  BackwardError, TruncationError, RoundOffError, AbsoluteTolerance,
  RelativeTolerance, StoppingCriterion, Convergence, ConvergenceRate,
  Divergence, Stagnation, Conditioning, ConditionNumber, Sensitivity,
  NumericalStability, MachinePrecision, InitialGuess, InitialBracket,
  BasinOfAttraction, MultipleRoot, SingularJacobian,
  OverdeterminedSystem, UnderdeterminedSystem, LeastSquaresSolution,
  Constraint, Domain, Existence, Uniqueness, Verification,
  ReferenceSolution, Reproducibility
 ]
 EXPAND(EquationFamilies) -> [
  LinearEquationSolving,
  LinearSystemSolving,
  ScalarRootFinding,
  NonlinearEquationSolving,
  NonlinearSystemSolving,
  IterativeEquationSolving,
  EquationVerification
 ]
 STOP_CONDITION = "Stop when equation class, domain, solution method, convergence, error, constraints and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics Ontologies"
 RELATED_ONTOLOGIES = [
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Linear Algebra Computation",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Optimisation Ontologies"
 ]
 ROUTE_RULES = [
  "Solving Equations -> Computational Mathematics for parent semantics",
  "Solving Equations -> Numerical Methods for numerical algorithms",
  "Solving Equations -> Numerical Linear Algebra for matrix systems",
  "Solving Equations -> Numerical Analysis for convergence and conditioning",
  "Solving Equations -> Numerical Error for residual and solution-error semantics",
  "Solving Equations -> Numerical Stability for finite-precision behaviour",
  "Solving Equations -> Numerical Convergence for iterative limits",
  "Solving Equations -> Optimisation when equation solving is embedded in optimality conditions"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible equation classes, solvers or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve exact-versus-approximate solution distinction.",
  "Preserve scalar-versus-system distinction.",
  "Preserve linear-versus-nonlinear distinction.",
  "Preserve direct-versus-iterative method distinction.",
  "Preserve residual-versus-solution-error distinction.",
  "Preserve existence-versus-uniqueness distinction.",
  "Preserve transformed-equation-versus-original-equation distinction.",
  "Preserve machine-readable equation-solving semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Solving equations determines unknown quantities satisfying one or more equations under declared domains and constraints."
 CLASSIFICATION_SUMMARY = "Equation structure determines suitable analytical, direct, iterative or root-finding methods."
 ROOT_SUMMARY = "Bisection, false position, secant, Newton and hybrid methods solve scalar root problems under different assumptions."
 SYSTEM_SUMMARY = "Linear and nonlinear systems require matrix, Jacobian or iterative solver reasoning."
 CONVERGENCE_SUMMARY = "Iterative methods require explicit convergence and stopping criteria."
 ERROR_SUMMARY = "Residual, forward error, backward error, conditioning and finite precision provide complementary quality measures."
 VERIFICATION_SUMMARY = "Candidate solutions must be checked against the original equation, domain and constraints."
}

FLOW {
 INPUT
 -> detect_equation_solving_context
 -> identify_equation_unknowns_domain_constraints_and_accuracy_goal
 -> classify_linear_nonlinear_scalar_system_polynomial_transcendental_or_other_equation
 -> assess_existence_uniqueness_and_domain_conditions
 -> select_symbolic_direct_bracketing_Newton_secant_fixed_point_Krylov_or_hybrid_method
 -> determine_initial_guess_bracket_scaling_or_preconditioner
 -> execute_solution_process
 -> monitor_residual_step_size_convergence_rate_and_stagnation
 -> assess_conditioning_forward_backward_roundoff_and_truncation_error
 -> verify_candidate_against_original_equation_domain_and_constraints
 -> route_to_related_computational_mathematics_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Solving Equations ontology defines computational methods for determining unknown quantities satisfying mathematical equations. It supports exact and approximate solutions, linear and nonlinear equations and systems, polynomial and transcendental equations, scalar root finding, bisection, false position, secant, Newton, fixed-point, Brent and hybrid methods, direct and iterative linear solvers, Jacobians, residuals, forward and backward error, tolerances, convergence and stagnation, conditioning and numerical stability, initial guesses and brackets, multiple roots, singular Jacobians, overdetermined and underdetermined systems, least-squares solutions, domain constraints, existence, uniqueness, verification and reproducibility."
}

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

}

END_FLOW