Nonlinear Solver Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Nonlinear Solver Ontology within the Kireth Research Semantic Library. A nonlinear solver is a computational method for determining values or vectors that satisfy nonlinear equations or systems such as f(x)=0 or F(x)=0. This ontology supports scalar and multivariable problems, Newton and quasi-Newton methods, fixed-point iteration, secant and derivative-free methods, damping, line search, trust regions, continuation, Jacobians, residuals, convergence, conditioning, numerical stability, multiple roots, singular Jacobians and verification.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NonlinearSolver
 ENTITY_CLASS = ComputationalNonlinearEquationSolutionFramework
 PRIMARY_CONTEXT = SolvingEquations
 DEFINITION = "A nonlinear solver is an algorithmic procedure for computing approximate or exact values satisfying one or more nonlinear equations."
 SYMBOLIC_FORMS = [
  "f(x)=0",
  "F(x)=0",
  "J(x_k)*delta_k=-F(x_k)",
  "x_(k+1)=x_k+delta_k"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for nonlinear equation classification, iterative solution, Jacobian-based and derivative-free methods, globalization, convergence, residuals, sensitivity, numerical stability and verification."
}

SCOPE {
 INCLUDE = [
  NonlinearSolver, NonlinearEquationSolver, NonlinearSystemSolver,
  ScalarNonlinearSolver, MultivariableNonlinearSolver,
  NonlinearEquation, NonlinearSystem, ResidualFunction, ResidualVector,
  Root, Solution, ApproximateSolution, InitialGuess, InitialVector,
  NewtonMethod, NewtonRaphsonMethod, ModifiedNewtonMethod,
  DampedNewtonMethod, InexactNewtonMethod, NewtonKrylovMethod,
  JacobianFreeNewtonKrylov, JFNK, SecantMethod, BroydenMethod,
  QuasiNewtonMethod, FixedPointIteration, PicardIteration,
  SteffensenMethod, BrentMethod, HybridMethod, DerivativeFreeMethod,
  TrustRegionMethod, LineSearch, Damping, StepLength,
  MeritFunction, ContinuationMethod, HomotopyMethod,
  PredictorCorrectorMethod, PseudoArclengthContinuation,
  Jacobian, JacobianMatrix, Derivative, DirectionalDerivative,
  FiniteDifferenceJacobian, AutomaticDifferentiation,
  NumericalDifferentiation, Linearisation, NewtonStep,
  SearchDirection, StepAcceptance, ForcingTerm, InexactSolve,
  InnerLinearSolver, Preconditioner, KrylovMethod, GMRES,
  Residual, ResidualNorm, RelativeResidual, StepNorm,
  FunctionTolerance, StepTolerance, ResidualTolerance,
  AbsoluteTolerance, RelativeTolerance, StoppingCriterion,
  MaximumIterations, MaximumEvaluations, Convergence,
  ConvergenceRate, LinearConvergence, SuperlinearConvergence,
  QuadraticConvergence, LocalConvergence, GlobalConvergence,
  BasinOfAttraction, Divergence, Stagnation, Cycling,
  Breakdown, MultipleRoot, RepeatedRoot, SimpleRoot,
  SingularJacobian, NearlySingularJacobian, IllConditionedJacobian,
  ConditionNumber, Conditioning, Sensitivity, Scaling,
  VariableScaling, EquationScaling, NumericalStability,
  FloatingPointArithmetic, MachinePrecision, RoundOffError,
  ForwardError, BackwardError, SolverStatus, Success, Failure,
  Warning, Verification, SubstitutionCheck, ReferenceSolution,
  Benchmarking, Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  LinearSolverWhenProblemIsStrictlyLinear,
  OptimisationSolverWithoutEquationRootSemantics,
  SymbolicManipulationWithoutNonlinearSolutionSearch,
  DifferentialEquationIntegratorWithoutRootFindingContext
 ]
 DISAMBIGUATION_RULE = "When the task is to compute unknown quantities satisfying nonlinear equations or systems, interpret the context as a nonlinear solver."
}

CORE_CONCEPTS {
 NonlinearSolver = "Computational method for solving nonlinear equations or systems."
 NewtonMethod = "Local iterative method based on first-order linearisation."
 Jacobian = "Matrix of first derivatives of a vector-valued nonlinear function."
 FixedPointIteration = "Iteration x_(k+1)=g(x_k) for a reformulated nonlinear equation."
 QuasiNewtonMethod = "Method approximating derivative or Jacobian information rather than recomputing it exactly."
 GlobalisationMethod = "Mechanism such as damping, line search or trust region used to improve convergence from nonlocal initial guesses."
 ContinuationMethod = "Method tracing solutions as a parameter changes."
 BasinOfAttraction = "Set of initial guesses converging to a particular solution under a specified iteration."
}

RELATIONS {
 NonlinearSolver --is_child_of--> EquationSolver
 NonlinearSolver --solves--> NonlinearEquation
 NonlinearSystemSolver --solves--> NonlinearSystem
 NewtonMethod --uses--> Jacobian
 NewtonMethod --produces--> NewtonStep
 NewtonStep --requires--> LinearSystemSolution
 InexactNewtonMethod --uses--> InexactLinearSolve
 NewtonKrylovMethod --uses--> KrylovMethod
 JacobianFreeNewtonKrylov --avoids_explicit--> JacobianAssembly
 QuasiNewtonMethod --approximates--> JacobianOrInverseJacobian
 BroydenMethod --is_type_of--> QuasiNewtonMethod
 FixedPointIteration --uses--> FixedPointMap
 LineSearch --controls--> StepLength
 TrustRegionMethod --controls--> StepMagnitude
 MeritFunction --guides--> StepAcceptance
 ContinuationMethod --tracks--> SolutionBranch
 Residual --measures--> NonlinearEquationMismatch
 SingularJacobian --can_cause--> SolverBreakdown
 Scaling --can_improve--> NumericalBehaviour
 Verification --checks--> CandidateSolution
}

OPERATORS {
 NONLINEAR_ROOT(f,x) := f(x)=0
 NONLINEAR_SYSTEM(F,x) := F(x)=0
 NEWTON_SCALAR(x,f) := x_next=x-f(x)/f_prime(x)
 NEWTON_SYSTEM(x,F,J) := solve(J(x)*delta=-F(x)); x_next=x+delta
 DAMPED_NEWTON(x,delta,alpha) := x_next=x+alpha*delta
 FIXED_POINT(x,g) := x_next=g(x)
 SECANT(x0,x1,f) := x_next=x1-f(x1)*(x1-x0)/(f(x1)-f(x0))
 BROYDEN_UPDATE(B,s,y) := B_next=B+((y-B*s)*s^T)/(s^T*s)
 RESIDUAL(F,x) := r=F(x)
 RELATIVE_RESIDUAL(F,x,scale) := ||F(x)||/scale
}

AXIOMS {
 A1 = "Nonlinear solver convergence is generally local unless a globalisation mechanism or special structure provides stronger guarantees."
 A2 = "Initialisation can determine which solution is reached when multiple roots exist."
 A3 = "Residual size and solution error are distinct."
 A4 = "Newton-type local quadratic convergence requires suitable smoothness, a nonsingular Jacobian at the solution and sufficiently close initialisation."
 A5 = "Repeated roots can reduce the convergence rate of standard Newton iteration."
 A6 = "A singular or nearly singular Jacobian can make Newton steps unstable or undefined."
 A7 = "Problem conditioning and solver stability are distinct."
 A8 = "Nonlinear solutions require explicit convergence, termination and verification semantics."
}

REASONING {
 R1_CONTEXT = identify(problem_dimension,equation_structure,derivative_availability,constraints,accuracy_goal)
 R2_INITIALISE = choose(initial_guess,scaling,and_if_possible_bracket_or_continuation_parameter)
 R3_METHOD = select(Newton,damped_Newton,quasi_Newton,secant,fixed_point,trust_region,continuation_or_hybrid_method)
 R4_DERIVATIVE = obtain(Jacobian_exact_AD_finite_difference_or_approximate)
 R5_STEP = compute_search_direction_or_Newton_step)
 R6_GLOBALISE = apply(line_search,damping,trust_region_or_continuation_if_needed)
 R7_ITERATE = update_solution_and_recompute_residual)
 R8_CONVERGENCE = monitor(residual,step_norm,rate,stagnation,cycling_and_breakdown)
 R9_SENSITIVITY = assess(Jacobian_conditioning,root_multiplicity,roundoff_and_scaling)
 R10_VERIFY = substitute_candidate_into_original_equations_and_check_constraints_reproducibility)
}

CONSTRAINTS {
 C1 = "Newton iteration can diverge or converge to an unintended root from a poor initial guess."
 C2 = "Fixed-point convergence requires suitable contractive behaviour near the solution."
 C3 = "Finite-difference Jacobians depend on perturbation size and can suffer truncation-roundoff tradeoffs."
 C4 = "Repeated roots reduce standard Newton convergence unless multiplicity is handled."
 C5 = "Singular Jacobians can make the local linear model unreliable."
 C6 = "Line searches and trust regions improve robustness but add evaluation cost."
 C7 = "A small residual may not imply a small forward error for ill-conditioned roots."
 C8 = "Inexact Newton methods require inner-solve tolerances consistent with outer convergence."
 C9 = "Scaling can materially alter nonlinear solver performance."
 C10 = "Stopping tolerances below attainable precision can cause stagnation."
}

SEMANTIC_EQUIVALENCE {
 "NonlinearSolver" <=> "NonlinearEquationSolver"
 "NewtonRaphsonMethod" <=> "NewtonMethod"
 "JacobianFreeNewtonKrylov" <=> "JFNK"
 "PicardIteration" <=> "FixedPointIterationInManyContexts"
 "QuasiNewtonMethod" <=> "ApproximateJacobianMethod"
}

VALIDATION {
 V1 = "Original nonlinear equations and domain are explicit."
 V2 = "Initial guess or continuation state is documented."
 V3 = "Solver method and derivative strategy are documented."
 V4 = "Residual and step stopping criteria are documented."
 V5 = "Termination reason is explicit."
 V6 = "Jacobian conditioning is assessed when relevant."
 V7 = "Multiple roots or multiple solution branches are considered where possible."
 V8 = "Candidate solutions satisfy original constraints and domain."
 V9 = "Residuals are evaluated using the original nonlinear equations."
 V10 = "Results are reproducible under documented arithmetic and solver settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NONLINEAR_SOLVER_DEFINITION = 0.99
 NEWTON_REASONING = 0.99
 FIXED_POINT_REASONING = 0.98
 QUASI_NEWTON_REASONING = 0.98
 GLOBALISATION_REASONING = 0.99
 CONTINUATION_REASONING = 0.98
 CONDITIONING_REASONING = 0.98
 POLICY = "Reduce confidence when initialisation, derivative quality, Jacobian conditioning, multiplicity, globalisation, stopping criteria or arithmetic precision are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch, OntologyGrounding, NonlinearSolverReasoning,
  NewtonMethodReasoning, JacobianReasoning, DampedNewtonReasoning,
  InexactNewtonReasoning, NewtonKrylovReasoning, JFNKReasoning,
  SecantReasoning, BroydenReasoning, FixedPointReasoning,
  LineSearchReasoning, TrustRegionReasoning, ContinuationReasoning,
  ResidualReasoning, NonlinearConvergenceReasoning,
  BasinOfAttractionReasoning, MultipleRootReasoning,
  SingularJacobianReasoning, ConditioningReasoning,
  NumericalStabilityReasoning, VerificationReasoning,
  KnowledgeGraphConstruction, RetrievalAugmentation, RecursiveInference
 ]
 NORMALISE {
  "nonlinear solver" -> NonlinearSolver
  "non-linear solver" -> NonlinearSolver
  "Newton-Raphson" -> NewtonMethod
  "JFNK" -> JacobianFreeNewtonKrylov
  "Picard iteration" -> FixedPointIteration
  "Broyden" -> BroydenMethod
 }
}

EXECUTION_RULES {
 E1 = "If unknowns must satisfy nonlinear equations, activate NonlinearSolverOntology."
 E2 = "Choose initialisation deliberately because nonlinear solvers may have multiple basins of attraction."
 E3 = "If reliable derivatives are available, consider Newton-type methods."
 E4 = "If exact Jacobians are expensive, consider automatic differentiation, finite differences, quasi-Newton or Jacobian-free approaches."
 E5 = "If full Newton steps are unreliable, use damping, line search or trust-region globalisation."
 E6 = "If the problem is large, consider Newton-Krylov or Jacobian-free Newton-Krylov methods."
 E7 = "If tracking parameter-dependent solutions, consider continuation or homotopy."
 E8 = "Monitor residual, step norm, convergence rate, stagnation and breakdown."
 E9 = "Verify all returned solutions against the original nonlinear equations and constraints."
}

RECURSION {
 ENTRY = NonlinearSolver
 EXPAND(NonlinearSolver) -> [
  NonlinearEquationSolver, NonlinearSystemSolver, ScalarNonlinearSolver,
  MultivariableNonlinearSolver, NonlinearEquation, NonlinearSystem,
  ResidualFunction, Root, Solution, InitialGuess, InitialVector,
  NewtonMethod, ModifiedNewtonMethod, DampedNewtonMethod,
  InexactNewtonMethod, NewtonKrylovMethod, JacobianFreeNewtonKrylov,
  SecantMethod, BroydenMethod, QuasiNewtonMethod, FixedPointIteration,
  SteffensenMethod, BrentMethod, HybridMethod, DerivativeFreeMethod,
  TrustRegionMethod, LineSearch, Damping, MeritFunction,
  ContinuationMethod, HomotopyMethod, PredictorCorrectorMethod,
  PseudoArclengthContinuation, Jacobian, FiniteDifferenceJacobian,
  AutomaticDifferentiation, NumericalDifferentiation, Linearisation,
  NewtonStep, SearchDirection, StepAcceptance, InnerLinearSolver,
  Preconditioner, KrylovMethod, GMRES, Residual, ResidualNorm,
  StepNorm, FunctionTolerance, StepTolerance, ResidualTolerance,
  StoppingCriterion, MaximumIterations, Convergence, LinearConvergence,
  SuperlinearConvergence, QuadraticConvergence, LocalConvergence,
  BasinOfAttraction, Divergence, Stagnation, Cycling, Breakdown,
  MultipleRoot, RepeatedRoot, SingularJacobian, IllConditionedJacobian,
  ConditionNumber, Conditioning, Scaling, NumericalStability,
  FloatingPointArithmetic, MachinePrecision, RoundOffError,
  ForwardError, BackwardError, SolverStatus, Verification,
  Benchmarking, Reproducibility
 ]
 EXPAND(NonlinearSolverFamilies) -> [
  NewtonAndModifiedNewtonMethods,
  QuasiNewtonAndSecantMethods,
  FixedPointMethods,
  GlobalisedNonlinearMethods,
  NewtonKrylovMethods,
  ContinuationAndHomotopyMethods,
  NonlinearSolverVerification
 ]
 STOP_CONDITION = "Stop when problem structure, initialisation, derivative strategy, nonlinear method, globalisation, convergence, conditioning and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Equation Solver Ontology"
 RELATED_ONTOLOGIES = [
  "Equation Solver Ontology",
  "Solving Equations",
  "Linear Solver Ontology",
  "Numerical Methods",
  "Numerical Analysis Ontology 2",
  "Numerical Error Ontology",
  "Numerical Stability Ontology 2",
  "Numerical Convergence Ontology",
  "Floating Point Arithmetic Ontology",
  "Machine Precision Ontology"
 ]
 ROUTE_RULES = [
  "Nonlinear Solver -> Equation Solver for parent solver semantics",
  "Nonlinear Solver -> Linear Solver for Newton and inexact-Newton inner systems",
  "Nonlinear Solver -> Numerical Methods for iterative algorithms",
  "Nonlinear Solver -> Numerical Analysis for convergence and conditioning",
  "Nonlinear Solver -> Numerical Error for residual and solution-error semantics",
  "Nonlinear Solver -> Numerical Stability for finite-precision behaviour",
  "Nonlinear Solver -> Numerical Convergence for local and global convergence behaviour",
  "Nonlinear Solver -> Floating Point Arithmetic for round-off effects"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible nonlinear solver methods, globalisation strategies or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve linear-versus-nonlinear solver distinction.",
  "Preserve scalar-versus-system distinction.",
  "Preserve local-convergence-versus-globalisation distinction.",
  "Preserve exact-Jacobian-versus-approximate-Jacobian distinction.",
  "Preserve outer-nonlinear-versus-inner-linear solve distinction.",
  "Preserve residual-versus-forward-error distinction.",
  "Preserve solver-status-versus-solution-validity distinction.",
  "Preserve machine-readable nonlinear-solver semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "A nonlinear solver computes unknown values or vectors satisfying nonlinear equations or systems."
 NEWTON_SUMMARY = "Newton methods solve local linearised systems using derivative or Jacobian information."
 QUASI_NEWTON_SUMMARY = "Secant and Broyden-style methods approximate derivative information to reduce derivative cost."
 GLOBALISATION_SUMMARY = "Damping, line search and trust regions improve robustness away from the local convergence region."
 LARGE_SCALE_SUMMARY = "Newton-Krylov and Jacobian-free methods support large nonlinear systems without forming dense Jacobians."
 CONTINUATION_SUMMARY = "Continuation and homotopy methods track solution branches as parameters vary."
 ERROR_SUMMARY = "Residuals, Jacobian conditioning, forward error, backward error and finite precision provide complementary quality measures."
 VALIDATION_SUMMARY = "Nonlinear solutions should be checked against the original equations, domain, constraints, convergence status and reproducibility."
}

FLOW {
 INPUT
 -> detect_nonlinear_solver_context
 -> identify_problem_dimension_equation_structure_derivative_availability_constraints_and_accuracy_goal
 -> choose_initial_guess_scaling_and_optional_continuation_state
 -> select_Newton_damped_Newton_quasi_Newton_secant_fixed_point_trust_region_NewtonKrylov_continuation_or_hybrid_method
 -> obtain_exact_AD_finite_difference_or_approximate_Jacobian_information
 -> compute_search_direction_or_Newton_step
 -> apply_damping_line_search_trust_region_or_continuation_if_required
 -> update_solution_and_recompute_residual
 -> monitor_residual_step_norm_convergence_rate_stagnation_cycling_and_breakdown
 -> assess_Jacobian_conditioning_multiplicity_roundoff_and_scaling
 -> classify_solver_status
 -> verify_candidate_against_original_equations_domain_and_constraints
 -> route_to_related_equation_solver_linear_solver_and_numerical_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Nonlinear Solver Ontology defines computational methods for solving nonlinear equations and systems. It supports scalar and multivariable problems, Newton, modified Newton, damped and inexact Newton methods, Newton-Krylov and Jacobian-free Newton-Krylov approaches, secant, Broyden and quasi-Newton methods, fixed-point and Steffensen iteration, Brent and hybrid methods, line searches, trust regions, damping, merit functions, continuation and homotopy, Jacobians from exact derivatives, automatic differentiation or finite differences, inner linear solvers and preconditioning, residual and step tolerances, local, superlinear and quadratic convergence, basins of attraction, multiple roots, singular Jacobians, conditioning, scaling, numerical stability, finite precision, solver status, verification, benchmarking and reproducibility."
}

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

}

END_FLOW