Computational Mathematics Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Computational Mathematics Ontology 2 within the Kireth Research Semantic Library. It formalises the core concepts and reasoning structures of computational mathematics, including exact and approximate computation, numerical representation, algorithms, discretisation, numerical linear algebra, approximation, root finding, numerical integration and differentiation, optimisation, complexity, floating-point arithmetic, conditioning, stability, convergence, verification and reproducibility.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Computational Mathematics Ontology 2"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Foundations of Computational Mathematics / Core Computational Mathematics"
 CANONICAL_PAGE = "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/foundations-of-computational-mathematics/computational-mathematics-ontology-2.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = ComputationalMathematicsOntology
 ENTITY_CLASS = CoreComputationalMathematicsFramework
 PRIMARY_CONTEXT = FoundationsOfComputationalMathematics
 DEFINITION = "The Computational Mathematics Ontology formalises the mathematical concepts, representations, algorithms and validation principles used to solve mathematical problems by computation."
 SYMBOLIC_FORMS = [
  "x_(k+1)=F(x_k)",
  "A x=b",
  "u_h approximates u",
  "error=exact-approximation"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for computational problem formulation, numerical algorithms, symbolic methods, approximation, discretisation, conditioning, stability, convergence, complexity and computational validation."
}

SCOPE {
 INCLUDE = [
  ComputationalMathematicsOntology,
  ComputationalMathematics,
  MathematicalComputation,
  ComputationalProblem,
  Algorithm,
  NumericalAlgorithm,
  SymbolicAlgorithm,
  DeterministicAlgorithm,
  RandomisedAlgorithm,
  ExactComputation,
  ApproximateComputation,
  NumericalRepresentation,
  SymbolicRepresentation,
  DiscreteRepresentation,
  ContinuousRepresentation,
  FloatingPointArithmetic,
  MachinePrecision,
  MachineEpsilon,
  RoundoffError,
  TruncationError,
  ApproximationError,
  DiscretisationError,
  IterationError,
  Residual,
  ForwardError,
  BackwardError,
  AbsoluteError,
  RelativeError,
  ErrorBound,
  ErrorPropagation,
  Conditioning,
  ConditionNumber,
  Stability,
  NumericalStability,
  BackwardStability,
  Consistency,
  Convergence,
  ConvergenceRate,
  StoppingCriterion,
  Tolerance,
  DirectMethod,
  IterativeMethod,
  RootFinding,
  FixedPointIteration,
  BisectionMethod,
  NewtonMethod,
  SecantMethod,
  NumericalDifferentiation,
  NumericalIntegration,
  Quadrature,
  Interpolation,
  PolynomialInterpolation,
  SplineInterpolation,
  ApproximationTheory,
  PolynomialApproximation,
  SpectralApproximation,
  LinearSystem,
  MatrixComputation,
  SparseMatrix,
  EigenvalueProblem,
  MatrixDecomposition,
  NumericalLinearAlgebra,
  Discretisation,
  Mesh,
  Grid,
  BasisFunction,
  ProjectionMethod,
  GalerkinMethod,
  CollocationMethod,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod,
  NumericalODE,
  NumericalPDE,
  ComputationalOptimisation,
  LinearProgramming,
  NonlinearProgramming,
  ConvexOptimisation,
  GradientMethod,
  QuasiNewtonMethod,
  TrustRegionMethod,
  InteriorPointMethod,
  MonteCarloMethod,
  AlgorithmicComplexity,
  TimeComplexity,
  SpaceComplexity,
  BigONotation,
  Scalability,
  ParallelComputing,
  HighPerformanceComputing,
  Verification,
  Validation,
  Benchmarking,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  PureMathematicsWithoutComputationalMethod,
  SoftwareEngineeringWithoutMathematicalComputation,
  HardwareArchitectureWithoutMathematicalAlgorithmContext,
  DataProcessingWithoutMathematicalProblemSemantics
 ]
 DISAMBIGUATION_RULE = "When a mathematical problem is formulated and solved through explicit algorithms, numerical approximations or symbolic computation, interpret the context as computational mathematics."
}

CORE_CONCEPTS {
 ComputationalMathematicsOntology = "Formal ontology of mathematical computation and numerical reasoning."
 ComputationalProblem = "Mathematical problem represented in a form suitable for algorithmic solution."
 NumericalAlgorithm = "Algorithm producing numerical approximations to a mathematical target."
 SymbolicAlgorithm = "Algorithm manipulating exact symbolic mathematical expressions."
 Conditioning = "Sensitivity of the mathematical problem to input perturbations."
 Stability = "Sensitivity of the computational method to perturbations and finite arithmetic."
 Convergence = "Approach of computed approximations to the intended solution."
 Discretisation = "Finite computational representation of a continuous mathematical object or problem."
 ErrorAnalysis = "Study of sources, magnitude and propagation of computational error."
 Verification = "Checking whether the algorithm and implementation correctly solve the stated mathematical problem."
}

RELATIONS {
 ComputationalMathematicsOntology --is_child_of--> FoundationsOfComputationalMathematics
 ComputationalMathematicsOntology --formalises--> MathematicalComputation
 ComputationalProblem --is_solved_by--> Algorithm
 Algorithm --has--> ComputationalComplexity
 NumericalAlgorithm --produces--> ApproximateSolution
 SymbolicAlgorithm --produces--> SymbolicResult
 FloatingPointArithmetic --introduces--> RoundoffError
 Discretisation --introduces--> DiscretisationError
 IterativeMethod --uses--> StoppingCriterion
 Conditioning --describes--> ProblemSensitivity
 Stability --describes--> AlgorithmSensitivity
 Consistency --supports--> Convergence
 Residual --measures--> EquationMismatch
 BackwardError --measures--> NearbyProblemPerturbation
 NumericalLinearAlgebra --uses--> MatrixComputation
 FiniteDifferenceMethod --discretises--> DifferentialEquation
 FiniteElementMethod --discretises--> VariationalProblem
 ComputationalOptimisation --solves--> OptimisationProblem
 Verification --checks--> ComputationalImplementation
 Reproducibility --supports--> ComputationalTrust
}

OPERATORS {
 ABSOLUTE_ERROR(x_exact,x_approx) := |x_exact-x_approx|
 RELATIVE_ERROR(x_exact,x_approx) := |x_exact-x_approx|/|x_exact|
 CONDITION_NUMBER(A) := kappa(A)=||A||*||A^(-1)||
 RESIDUAL(A,x,b) := r=b-A*x
 FIXED_POINT_ITERATION(x,g) := x_next=g(x)
 NEWTON_ITERATION(x,f) := x_next=x-f(x)/f'(x)
 BISECTION_STEP(a,b) := midpoint=(a+b)/2
 FORWARD_DIFFERENCE(f,x,h) := (f(x+h)-f(x))/h
 CENTRAL_DIFFERENCE(f,x,h) := (f(x+h)-f(x-h))/(2*h)
 TRAPEZOID_RULE(f,a,b,n) := numerical_integral_by_piecewise_trapezoids
 OLS_LINEAR_SOLVE(A,b) := solve_minimum_norm_or_least_squares(A,b)
}

AXIOMS {
 A1 = "Computational mathematics requires an explicit mathematical problem and computational representation."
 A2 = "Approximate solutions require explicit error semantics."
 A3 = "Problem conditioning and algorithm stability are distinct."
 A4 = "Discretisation changes the representation but should preserve relevant mathematical structure."
 A5 = "Convergence requires a declared limiting process."
 A6 = "Finite-precision arithmetic differs from exact real-number arithmetic."
 A7 = "Algorithmic efficiency does not guarantee mathematical correctness."
 A8 = "Computational results require verification, validation and reproducibility where applicable."
}

REASONING {
 R1_CONTEXT = identify(problem,mathematical_structure,desired_output,accuracy_goal,resource_constraints)
 R2_REPRESENTATION = choose(exact,symbolic,numerical,discrete_or_continuous_representation)
 R3_METHOD = classify(direct,iterative,approximation,discretisation,optimisation,simulation_or_symbolic_method)
 R4_CONDITIONING = analyse(problem_sensitivity)
 R5_STABILITY = analyse(method_response_to_perturbations_and_roundoff)
 R6_ERROR = estimate(truncation,roundoff,discretisation,iteration_and_total_error)
 R7_CONVERGENCE = analyse(limit,rate,stopping_criterion)
 R8_COMPLEXITY = estimate(time,space,parallelism_and_scalability)
 R9_VERIFICATION = compare(residuals,error_bounds,reference_solutions_or_benchmarks)
 R10_VALIDATION = assess_correctness,reproducibility,robustness_and_assumptions)
}

CONSTRAINTS {
 C1 = "Exact solvability does not imply practical computability."
 C2 = "A stable algorithm can still perform poorly on an ill-conditioned problem."
 C3 = "A well-conditioned problem can still be solved poorly by an unstable algorithm."
 C4 = "Reducing step size can increase roundoff dominance."
 C5 = "A small residual can coexist with a large forward error in ill-conditioned systems."
 C6 = "Iterative convergence depends on method, spectrum, conditioning and stopping criteria."
 C7 = "Big-O complexity does not capture all practical performance factors."
 C8 = "Benchmark agreement does not prove validity outside the tested regime."
 C9 = "Symbolic exactness can become computationally infeasible."
 C10 = "Approximation methods require explicit validity and error regimes."
}

SEMANTIC_EQUIVALENCE {
 "ComputationalMathematicsOntology" <=> "CoreComputationalMathematicsOntology"
 "NumericalLinearAlgebra" <=> "ComputationalLinearAlgebra"
 "HighPerformanceComputing" <=> "HPC"
 "FiniteDifferenceMethod" <=> "FDM"
 "FiniteElementMethod" <=> "FEM"
 "FiniteVolumeMethod" <=> "FVM"
}

VALIDATION {
 V1 = "Mathematical problem and computational target are explicit."
 V2 = "Representation and precision are documented."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Stability is analysed or tested."
 V5 = "Major error sources are quantified."
 V6 = "Convergence and stopping criteria are documented."
 V7 = "Complexity and memory requirements are considered."
 V8 = "Reference or benchmark solutions are used where feasible."
 V9 = "Results are reproducible under documented settings."
 V10 = "Verification and validation are distinguished."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 COMPUTATIONAL_MATHEMATICS_ONTOLOGY_DEFINITION = 0.99
 REPRESENTATION_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 STABILITY_REASONING = 0.99
 ERROR_REASONING = 0.99
 CONVERGENCE_REASONING = 0.99
 COMPLEXITY_REASONING = 0.98
 VERIFICATION_REASONING = 0.98
 POLICY = "Reduce confidence when computational representation, precision, numerical method, conditioning, stability, tolerance, convergence regime or benchmark context are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  ComputationalMathematicsOntologyReasoning,
  ComputationalProblemReasoning,
  NumericalAlgorithmReasoning,
  SymbolicAlgorithmReasoning,
  FloatingPointReasoning,
  ErrorAnalysisReasoning,
  ConditioningReasoning,
  StabilityReasoning,
  ConvergenceReasoning,
  RootFindingReasoning,
  NumericalIntegrationReasoning,
  NumericalDifferentiationReasoning,
  NumericalLinearAlgebraReasoning,
  DiscretisationReasoning,
  NumericalODEResoning,
  NumericalPDEReasoning,
  OptimisationReasoning,
  ComplexityReasoning,
  VerificationReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]
 NORMALISE {
  "computational mathematics ontology" -> ComputationalMathematicsOntology
  "computational mathematics" -> ComputationalMathematics
  "numerical algorithm" -> NumericalAlgorithm
  "computer algebra" -> SymbolicAlgorithm
  "condition number" -> ConditionNumber
  "backward error" -> BackwardError
  "forward error" -> ForwardError
  "HPC" -> HighPerformanceComputing
 }
}

EXECUTION_RULES {
 E1 = "If a mathematical problem is explicitly represented for algorithmic solution, activate ComputationalMathematicsOntology."
 E2 = "If exact symbolic manipulation dominates, route to symbolic computation."
 E3 = "If approximation dominates, route to numerical analysis."
 E4 = "If matrix computation dominates, route to numerical linear algebra."
 E5 = "If differential equations are discretised, route to numerical ODE or PDE methods."
 E6 = "If an iterative method is used, define convergence and stopping criteria."
 E7 = "If scalability matters, analyse complexity, sparse structure and parallelism."
 E8 = "If finite precision matters, include floating-point and error analysis."
 E9 = "Any computational result should be verified for stability, error, convergence and reproducibility."
}

RECURSION {
 ENTRY = ComputationalMathematicsOntology
 EXPAND(ComputationalMathematicsOntology) -> [
  ComputationalMathematics, MathematicalComputation, ComputationalProblem,
  Algorithm, NumericalAlgorithm, SymbolicAlgorithm, DeterministicAlgorithm,
  RandomisedAlgorithm, ExactComputation, ApproximateComputation,
  NumericalRepresentation, SymbolicRepresentation, DiscreteRepresentation,
  ContinuousRepresentation, FloatingPointArithmetic, MachinePrecision,
  MachineEpsilon, RoundoffError, TruncationError, ApproximationError,
  DiscretisationError, IterationError, Residual, ForwardError,
  BackwardError, AbsoluteError, RelativeError, ErrorBound,
  ErrorPropagation, Conditioning, ConditionNumber, Stability,
  NumericalStability, BackwardStability, Consistency, Convergence,
  ConvergenceRate, StoppingCriterion, Tolerance, DirectMethod,
  IterativeMethod, RootFinding, FixedPointIteration, BisectionMethod,
  NewtonMethod, SecantMethod, NumericalDifferentiation,
  NumericalIntegration, Quadrature, Interpolation,
  PolynomialInterpolation, SplineInterpolation, ApproximationTheory,
  PolynomialApproximation, SpectralApproximation, LinearSystem,
  MatrixComputation, SparseMatrix, EigenvalueProblem, MatrixDecomposition,
  NumericalLinearAlgebra, Discretisation, Mesh, Grid, BasisFunction,
  ProjectionMethod, GalerkinMethod, CollocationMethod,
  FiniteDifferenceMethod, FiniteElementMethod, FiniteVolumeMethod,
  SpectralMethod, NumericalODE, NumericalPDE, ComputationalOptimisation,
  LinearProgramming, NonlinearProgramming, ConvexOptimisation,
  GradientMethod, QuasiNewtonMethod, TrustRegionMethod,
  InteriorPointMethod, MonteCarloMethod, AlgorithmicComplexity,
  TimeComplexity, SpaceComplexity, BigONotation, Scalability,
  ParallelComputing, HighPerformanceComputing, Verification,
  Validation, Benchmarking, Reproducibility
 ]
 EXPAND(CoreFamilies) -> [
  NumericalFoundations,
  NumericalLinearAlgebra,
  ApproximationMethods,
  NumericalDifferentialEquations,
  ComputationalOptimisation,
  ComplexityAndScalability,
  VerificationAndValidation
 ]
 STOP_CONDITION = "Stop when problem, representation, method, error, stability, convergence, complexity and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Foundations of Computational Mathematics"
 RELATED_ONTOLOGIES = [
  "Foundations of Computational Mathematics",
  "Computational Mathematics Ontologies",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Approximation Theory Ontologies",
  "Differential Equation Ontologies",
  "Optimisation Ontologies",
  "Computer Algebra Ontologies",
  "Discrete Mathematics Ontologies",
  "Scientific Computing Ontologies"
 ]
 ROUTE_RULES = [
  "Computational Mathematics Ontology -> Foundations of Computational Mathematics for parent semantics",
  "Computational Mathematics Ontology -> Numerical Analysis for stability, error and convergence",
  "Computational Mathematics Ontology -> Numerical Linear Algebra for matrix computation",
  "Computational Mathematics Ontology -> Approximation Theory for interpolation and approximation",
  "Computational Mathematics Ontology -> Differential Equations for numerical ODE and PDE methods",
  "Computational Mathematics Ontology -> Optimisation for computational optimisation",
  "Computational Mathematics Ontology -> Computer Algebra for exact symbolic methods",
  "Computational Mathematics Ontology -> Discrete Mathematics for algorithmic structure",
  "Computational Mathematics Ontology -> Scientific Computing for applied computational models"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible algorithms, representations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve exact-versus-approximate computation distinction.",
  "Preserve symbolic-versus-numerical distinction.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve forward-versus-backward error distinction.",
  "Preserve direct-versus-iterative method distinction.",
  "Preserve convergence semantics.",
  "Preserve verification-versus-validation distinction.",
  "Preserve machine-readable computational-mathematics semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "The Computational Mathematics Ontology formalises the mathematical structures and algorithms used for reliable machine computation."
 REPRESENTATION_SUMMARY = "Computational problems require explicit numerical, symbolic or discrete representations."
 ERROR_SUMMARY = "Roundoff, truncation, discretisation and iteration errors contribute to computational uncertainty."
 CONDITIONING_SUMMARY = "Conditioning describes problem sensitivity, while stability describes algorithm sensitivity."
 CONVERGENCE_SUMMARY = "Convergence determines whether approximations approach the intended solution."
 ALGORITHM_SUMMARY = "Direct, iterative, numerical, symbolic and randomised algorithms solve different classes of mathematical problems."
 COMPLEXITY_SUMMARY = "Time, space and scalability determine computational feasibility."
 VALIDATION_SUMMARY = "Computational results should be checked for conditioning, stability, error, convergence, verification and reproducibility."
}

FLOW {
 INPUT
 -> detect_computational_mathematics_ontology_context
 -> identify_mathematical_problem_representation_accuracy_goal_precision_and_compute_constraints
 -> classify_exact_symbolic_numerical_discrete_or_continuous_computation
 -> select_direct_iterative_approximation_discretisation_optimisation_simulation_or_symbolic_method
 -> analyse_conditioning_and_stability
 -> estimate_roundoff_truncation_discretisation_iteration_and_total_error
 -> assess_convergence_rate_stopping_criteria_and_tolerance
 -> assess_time_space_complexity_sparse_structure_parallelism_and_scalability
 -> verify_with_residuals_error_bounds_reference_solutions_or_benchmarks
 -> validate_reproducibility_and_model_assumptions
 -> route_to_foundations_computational_mathematics_numerical_analysis_linear_algebra_approximation_differential_equations_optimisation_computer_algebra_discrete_mathematics_or_scientific_computing_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Computational Mathematics Ontology formalises mathematical computation itself. It supports computational problems and algorithms, exact and approximate computation, numerical and symbolic representations, floating-point arithmetic and machine precision, roundoff, truncation, approximation, discretisation and iteration error, residuals, forward and backward error, conditioning and condition numbers, numerical stability, consistency and convergence, stopping criteria and tolerances, direct and iterative methods, root finding, numerical differentiation and integration, quadrature and interpolation, approximation theory, linear systems, sparse matrices, eigenvalue problems and matrix decomposition, numerical linear algebra, meshes, grids, projection, Galerkin and collocation methods, finite-difference, finite-element, finite-volume and spectral methods, numerical ODEs and PDEs, computational optimisation, Monte Carlo methods, algorithmic complexity, parallel and high-performance computing, verification, validation, benchmarking and reproducibility."
}

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

}

END_FLOW