Skip to main content

Computational Mathematics Ontology

Computational Mathematics
Authors: MArk Anthony Higgins - Sky Recursive Ai
© Mark Anthony Higgins 11 October 2025
Revised Date: 12 September 2026
AI Search Show Less
Audio Overview
Next Chapter 
AI INTERPRETATION NOTE
This Flow Algebra defines the Computational Mathematics Ontology within the Kireth Research Semantic Library. It formalises computational mathematics as a machine-readable ontology of algorithms, numerical approximation, symbolic computation, numerical linear algebra, discretisation, optimisation, error analysis, conditioning, stability, convergence, uncertainty, complexity and high-performance scientific computing. It sits beneath the Computational Mathematics parent layer and provides a structured reasoning framework for selecting, executing and validating mathematical computation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = ComputationalMathematicsOntology
 SYMBOLIC_FORMS = [
  "A x = b",
  "x_{k+1}=Phi(x_k)",
  "u_h -> u",
  "minimise f(x)",
  "error_h approximately C*h^p"
 ]
 ENTITY_CLASS = FormalAlgorithmicMathematicsOntology
 PRIMARY_CONTEXT = ComputationalMathematics
 DEFINITION = "The Computational Mathematics Ontology is a formal semantic framework for representing algorithms, numerical and symbolic methods, approximation, error, stability, convergence, complexity and computational validation."
 SEMANTIC_ROLE = "Provides machine-readable entities and reasoning relations for mathematical computation, algorithm selection, discretisation, numerical linear algebra, symbolic manipulation, optimisation, uncertainty quantification and scientific computing."
}

SCOPE {
 INCLUDE = [
  ComputationalMathematicsOntology,
  ComputationalMathematics,
  Algorithm,
  NumericalAlgorithm,
  SymbolicAlgorithm,
  DeterministicAlgorithm,
  StochasticAlgorithm,
  IterativeAlgorithm,
  DirectAlgorithm,
  ScientificComputing,
  NumericalAnalysis,
  NumericalLinearAlgebra,
  MatrixComputation,
  LinearSystem,
  SparseMatrix,
  DenseMatrix,
  MatrixFactorisation,
  LUFactorisation,
  QRFactorisation,
  CholeskyFactorisation,
  SingularValueDecomposition,
  EigenvalueProblem,
  Eigenvector,
  Approximation,
  ApproximationTheory,
  Interpolation,
  Extrapolation,
  NumericalDifferentiation,
  NumericalIntegration,
  Quadrature,
  RootFinding,
  FixedPointIteration,
  NewtonMethod,
  SecantMethod,
  BisectionMethod,
  KrylovMethod,
  ConjugateGradient,
  GMRES,
  Preconditioning,
  Discretisation,
  Mesh,
  Grid,
  BasisFunction,
  FiniteDifferenceMethod,
  FiniteVolumeMethod,
  FiniteElementMethod,
  SpectralMethod,
  NumericalODE,
  NumericalPDE,
  TimeIntegration,
  ExplicitMethod,
  ImplicitMethod,
  Stability,
  Consistency,
  Convergence,
  Conditioning,
  ConditionNumber,
  Residual,
  TruncationError,
  RoundoffError,
  DiscretisationError,
  IterationError,
  FloatingPointArithmetic,
  ErrorAnalysis,
  ComplexityAnalysis,
  ComputationalCost,
  MemoryCost,
  CommunicationCost,
  Optimisation,
  MonteCarloMethod,
  StochasticComputation,
  UncertaintyQuantification,
  SymbolicComputation,
  ComputerAlgebra,
  AutomaticDifferentiation,
  ParallelComputing,
  HighPerformanceComputing,
  Reproducibility,
  Verification,
  Validation
 ]

 EXCLUDE_AS_PRIMARY = [
  PureMathematicalTheoryWithoutComputationalRepresentation,
  GeneralProgrammingWithoutMathematicalProblemStructure,
  DataProcessingWithoutNumericalOrSymbolicMathematicsContext
 ]

 DISAMBIGUATION_RULE =
  "When a mathematical problem is represented, approximated, solved or validated through an algorithmic, numerical or symbolic process, interpret the context through the Computational Mathematics Ontology."
}

CORE_CONCEPTS {

 ComputationalMathematicsOntology {
  definition = "The ontology organising formal concepts and relationships used in computational mathematics."
 }

 Algorithm {
  definition = "A finite or iterative computational procedure for transforming input data into a mathematical result."
 }

 NumericalAlgorithm {
  definition = "An algorithm that computes approximate numerical solutions."
 }

 SymbolicAlgorithm {
  definition = "An algorithm that manipulates exact symbolic mathematical representations."
 }

 Approximation {
  definition = "A computable representation intended to approximate an exact mathematical object."
 }

 Conditioning {
  definition = "Sensitivity of a mathematical problem to perturbations in its input data."
 }

 Stability {
  definition = "Sensitivity of an algorithm to perturbations, discretisation effects or roundoff."
 }

 Convergence {
  definition = "Approach of computed approximations toward the intended mathematical solution."
 }

 Residual {
  definition = "The defect produced when an approximate solution is substituted into the governing equation."
 }

 ComplexityAnalysis {
  definition = "Analysis of algorithmic time, memory and communication requirements."
 }
}

RELATIONS {
 ComputationalMathematicsOntology --is_child_of--> ComputationalMathematics
 Algorithm --operates_on--> MathematicalRepresentation
 NumericalAlgorithm --produces--> Approximation
 SymbolicAlgorithm --produces--> SymbolicResult
 NumericalAnalysis --studies--> Stability
 NumericalAnalysis --studies--> Convergence
 NumericalAnalysis --studies--> Error
 NumericalLinearAlgebra --solves--> LinearSystem
 MatrixFactorisation --decomposes--> Matrix
 LUFactorisation --is_type_of--> MatrixFactorisation
 QRFactorisation --is_type_of--> MatrixFactorisation
 CholeskyFactorisation --is_type_of--> MatrixFactorisation
 SingularValueDecomposition --is_type_of--> MatrixFactorisation
 RootFinding --uses--> IterativeAlgorithm
 KrylovMethod --solves--> LargeSparseLinearSystem
 Preconditioning --improves--> IterativeConvergence
 Discretisation --maps--> ContinuousProblemToDiscreteProblem
 Mesh --supports--> Discretisation
 BasisFunction --supports--> FiniteElementMethod
 Residual --measures--> EquationDefect
 ConditionNumber --measures--> Conditioning
 FloatingPointArithmetic --introduces--> RoundoffError
 ComplexityAnalysis --measures--> ComputationalCost
 MonteCarloMethod --supports--> StochasticComputation
 AutomaticDifferentiation --computes--> DerivativeInformation
 ParallelComputing --accelerates--> ComputationalWorkload
 Verification --checks--> NumericalImplementation
 Validation --checks--> MathematicalModelAdequacy
}

OPERATORS {
 LINEAR_SYSTEM(A,x,b) :=
  A*x=b

 RESIDUAL(A,x,b) :=
  r=b-A*x

 FIXED_POINT_ITERATION(Phi,x_k) :=
  x_{k+1}=Phi(x_k)

 NEWTON_UPDATE(f,df,x_k) :=
  x_{k+1}=x_k-f(x_k)/df(x_k)

 SECANT_UPDATE(f,x_k,x_km1) :=
  x_{k+1}=x_k-f(x_k)*(x_k-x_km1)/(f(x_k)-f(x_km1))

 BISECTION_UPDATE(a,b) :=
  c=(a+b)/2

 CONDITION_NUMBER(A) :=
  kappa(A)=||A||*||A^(-1)||

 ABSOLUTE_ERROR(x_true,x_approx) :=
  e_abs=abs(x_true-x_approx)

 RELATIVE_ERROR(x_true,x_approx) :=
  e_rel=abs(x_true-x_approx)/abs(x_true)

 FINITE_DIFFERENCE_FIRST_DERIVATIVE(f,x,h) :=
  f_prime(x) approximately (f(x+h)-f(x))/h

 CONVERGENCE_RATE(e_h,e_h2,h,h2) :=
  p approximately log(e_h/e_h2)/log(h/h2)

 MONTE_CARLO_ESTIMATE(samples) :=
  estimator=sample_average

 ASYMPTOTIC_COMPLEXITY(n) :=
  cost=O(g(n))

 SPEEDUP(T1,Tp) :=
  S_p=T1/Tp
}

DEFINITIONS {
 D1 = "Computational mathematics represents mathematical problems through algorithms and computable approximations."
 D2 = "Numerical algorithms produce approximate results whose error must be assessed."
 D3 = "Symbolic algorithms manipulate exact mathematical expressions."
 D4 = "Conditioning is a property of the mathematical problem."
 D5 = "Stability is a property of the computational method."
 D6 = "Consistency concerns approximation of the intended equations."
 D7 = "Convergence concerns approach to the intended solution under refinement."
 D8 = "Residual and solution error are related but are not generally identical."
 D9 = "Floating-point arithmetic introduces finite-precision effects."
 D10 = "Computational complexity determines practical scalability."
}

AXIOMS {
 A1_ALGORITHMIC_REPRESENTATION:
  ComputationalMathematicsOntology requires an explicit or implicit computational procedure

 A2_ERROR_ACCOUNTING:
  Numerical results require quantified or bounded approximation error where possible

 A3_CONDITIONING_STABILITY_DISTINCTION:
  Problem conditioning and algorithm stability must be distinguished

 A4_CONVERGENCE:
  Refinement or iteration must be tested for convergence where applicable

 A5_FINITE_PRECISION:
  Numerical implementation is subject to finite-precision arithmetic

 A6_COMPLEXITY:
  Computational feasibility depends on time memory and communication requirements

 A7_REPRODUCIBILITY:
  Reliable computation requires documented data algorithms tolerances and implementation assumptions

 A8_VERIFICATION_VALIDATION_DISTINCTION:
  Verification of numerical solution is distinct from validation of the underlying mathematical model
}

REASONING {

 R1_PROBLEM_EXTRACTION {
  INPUT = computational_mathematical_problem
  IDENTIFY = equations_or_objective
  IDENTIFY = dimensions_and_structure
  IDENTIFY = sparsity_or_symmetry
  IDENTIFY = accuracy_requirements
  IDENTIFY = computational_constraints
  RETURN = computational_problem_profile
 }

 R2_PROBLEM_CLASSIFICATION {
  INPUT = computational_problem_profile
  CLASSIFY = linear_or_nonlinear
  CLASSIFY = continuous_or_discrete
  CLASSIFY = deterministic_or_stochastic
  CLASSIFY = symbolic_or_numerical
  CLASSIFY = small_dense_or_large_sparse
  RETURN = problem_class
 }

 R3_ALGORITHM_SELECTION {
  INPUT = problem_class
  SELECT = direct_iterative_symbolic_discretisation_optimisation_or_stochastic family
  RETURN = candidate_algorithm
 }

 R4_CONDITIONING_REASONING {
  INPUT = mathematical_problem
  COMPUTE_OR_ESTIMATE = condition_number_or_sensitivity
  RETURN = conditioning_profile
 }

 R5_DISCRETISATION_REASONING {
  INPUT = continuous_problem
  SELECT = finiteDifference_finiteVolume_finiteElement_spectral_or_other method
  DEFINE = mesh_basis_and_resolution
  RETURN = discrete_problem
 }

 R6_ITERATIVE_REASONING {
  INPUT = nonlinear_or_large_linear problem
  SELECT = fixedPoint_Newton_Krylov_or_related method
  DEFINE = preconditioner_and_stopping criteria
  RETURN = iteration_profile
 }

 R7_ERROR_REASONING {
  INPUT = approximation_reference_residual_and_resolution data
  ESTIMATE = truncation_discretisation_iteration_roundoff error
  RETURN = error_profile
 }

 R8_CONVERGENCE_REASONING {
  INPUT = sequence_of_solutions
  TEST = residual_or_error reduction
  ESTIMATE = observed_order
  RETURN = convergence_profile
 }

 R9_COMPLEXITY_AND_PARALLEL_REASONING {
  INPUT = algorithm_problem size_hardware model
  ESTIMATE = arithmetic_memory_communication cost
  ANALYSE = parallel_speedup_and_scalability
  RETURN = computational_cost_profile
 }

 R10_VERIFICATION_VALIDATION {
  INPUT = computational_result
  CHECK = residuals_error convergence_reference cases_reproducibility_and_model relevance
  RETURN = trusted_computational_result
 }
}

CONSTRAINTS {
 C1 = "Small residual does not imply small solution error for every conditioned problem."
 C2 = "A converged numerical method may converge to the wrong model or wrong discrete branch."
 C3 = "Higher formal order does not guarantee higher accuracy on nonsmooth problems."
 C4 = "Roundoff can dominate when resolution becomes excessively fine."
 C5 = "Iterative stopping tolerance must be related to the required output accuracy."
 C6 = "Sparse structure should not be destroyed unnecessarily in large problems."
 C7 = "Parallel scalability is limited by serial fractions and communication."
 C8 = "Monte Carlo error is statistical and decays differently from deterministic discretisation error."
 C9 = "Automatic differentiation is exact up to floating-point arithmetic but does not correct an incorrect model."
 C10 = "Symbolic computation can suffer expression swell and combinatorial growth."
}

SEMANTIC_EQUIVALENCE {
 "ComputationalMathematicsOntology" <=> "FormalComputationalMathematicsOntology"
 "NumericalLinearAlgebra" <=> "ComputationalLinearAlgebra"
 "Conditioning" <=> "ProblemSensitivity"
 "RoundoffError" <=> "FloatingPointError"
 "HighPerformanceComputing" <=> "HPC"
 "Verification" <=> "NumericalVerification"
}

VALIDATION {
 V1 = "Mathematical problem definition is explicit."
 V2 = "Algorithm choice is justified."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Residuals are computed."
 V5 = "Discretisation or iteration convergence is checked."
 V6 = "Error norms and metrics are documented."
 V7 = "Floating-point precision assumptions are explicit."
 V8 = "Computational cost is assessed for large-scale problems."
 V9 = "Results are reproducible within expected numerical variation."
 V10 = "Verification and model validation are separately documented."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 COMPUTATIONAL_MATHEMATICS_ONTOLOGY_DEFINITION = 0.99
 PROBLEM_CLASSIFICATION_REASONING = 0.99
 ALGORITHM_SELECTION_REASONING = 0.99
 CONDITIONING_REASONING = 0.99
 DISCRETISATION_REASONING = 0.99
 ITERATIVE_REASONING = 0.99
 ERROR_REASONING = 0.99
 CONVERGENCE_REASONING = 0.99
 COMPLEXITY_REASONING = 0.98

 POLICY =
  "Reduce confidence when problem structure, conditioning, discretisation, tolerances, precision, error norms, convergence evidence, hardware assumptions or reference validation are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  ComputationalMathematicsOntologyReasoning,
  AlgorithmReasoning,
  NumericalAlgorithmReasoning,
  SymbolicAlgorithmReasoning,
  NumericalLinearAlgebraReasoning,
  MatrixFactorisationReasoning,
  RootFindingReasoning,
  IterativeMethodReasoning,
  DiscretisationReasoning,
  ErrorAnalysisReasoning,
  ConditioningReasoning,
  StabilityReasoning,
  ConvergenceReasoning,
  ComplexityReasoning,
  MonteCarloReasoning,
  AutomaticDifferentiationReasoning,
  ParallelComputingReasoning,
  HighPerformanceComputingReasoning,
  VerificationReasoning,
  ValidationReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "computational mathematics ontology" -> ComputationalMathematicsOntology
  "computational mathematics" -> ComputationalMathematics
  "numerical algorithm" -> NumericalAlgorithm
  "symbolic algorithm" -> SymbolicAlgorithm
  "numerical linear algebra" -> NumericalLinearAlgebra
  "condition number" -> ConditionNumber
  "floating-point error" -> RoundoffError
  "automatic differentiation" -> AutomaticDifferentiation
  "high-performance computing" -> HighPerformanceComputing
  "HPC" -> HighPerformanceComputing
 }

 INTERPRETATION_ORDER = [
  detect_computational_mathematics_ontology_context,
  identify equations_objectives_problem size_structure_accuracy_requirements_and_resources,
  classify symbolic_numerical_linear_nonlinear_continuous_discrete_deterministic_stochastic_dense_or_sparse structure,
  assess conditioning_and_problem sensitivity,
  select algorithm_discretisation_and_data representation,
  compute solution,
  estimate residual_error_and_convergence,
  assess complexity_parallelism_and_resource use,
  perform numerical_verification_and_model validation,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("computational mathematics ontology")
  OR formal_computational_mathematical_semantics_are_required
  THEN activate(ComputationalMathematicsOntology)

 E2:
  IF dense_linear_system
  THEN consider direct_factorisation methods

 E3:
  IF large_sparse_linear_system
  THEN consider Krylov_and_preconditioning methods

 E4:
  IF nonlinear_problem
  THEN consider Newton_fixedPoint_secant_or_related iteration

 E5:
  IF continuous_problem
  THEN choose suitable discretisation family

 E6:
  IF symbolic_structure_is_manageable
  THEN consider symbolic_or_computer algebra pathway

 E7:
  IF derivative_information_is_required
  THEN consider AutomaticDifferentiation

 E8:
  IF uncertainty_or_high_dimensional expectation
  THEN consider MonteCarlo_or_stochastic methods

 E9:
  IF large_computational_cost
  THEN assess sparse_parallel_and_HPC strategy
}

RECURSION {
 ENTRY = ComputationalMathematicsOntology

 EXPAND(ComputationalMathematicsOntology) -> [
  ComputationalMathematics,
  Algorithm,
  NumericalAlgorithm,
  SymbolicAlgorithm,
  DeterministicAlgorithm,
  StochasticAlgorithm,
  IterativeAlgorithm,
  DirectAlgorithm,
  ScientificComputing,
  NumericalAnalysis,
  NumericalLinearAlgebra,
  MatrixComputation,
  LinearSystem,
  SparseMatrix,
  DenseMatrix,
  MatrixFactorisation,
  LUFactorisation,
  QRFactorisation,
  CholeskyFactorisation,
  SingularValueDecomposition,
  EigenvalueProblem,
  Approximation,
  Interpolation,
  Extrapolation,
  NumericalDifferentiation,
  NumericalIntegration,
  Quadrature,
  RootFinding,
  FixedPointIteration,
  NewtonMethod,
  SecantMethod,
  BisectionMethod,
  KrylovMethod,
  ConjugateGradient,
  GMRES,
  Preconditioning,
  Discretisation,
  Mesh,
  Grid,
  BasisFunction,
  FiniteDifferenceMethod,
  FiniteVolumeMethod,
  FiniteElementMethod,
  SpectralMethod,
  NumericalODE,
  NumericalPDE,
  TimeIntegration,
  Stability,
  Consistency,
  Convergence,
  Conditioning,
  ConditionNumber,
  Residual,
  TruncationError,
  RoundoffError,
  DiscretisationError,
  IterationError,
  FloatingPointArithmetic,
  ErrorAnalysis,
  ComplexityAnalysis,
  Optimisation,
  MonteCarloMethod,
  StochasticComputation,
  UncertaintyQuantification,
  SymbolicComputation,
  ComputerAlgebra,
  AutomaticDifferentiation,
  ParallelComputing,
  HighPerformanceComputing,
  Reproducibility,
  Verification,
  Validation
 ]

 EXPAND(AlgorithmFamilies) -> [
  DirectAlgorithm,
  IterativeAlgorithm,
  NumericalAlgorithm,
  SymbolicAlgorithm,
  StochasticAlgorithm,
  ParallelAlgorithm
 ]

 EXPAND(NumericalQuality) -> [
  Conditioning,
  Stability,
  Consistency,
  Convergence,
  Residual,
  TruncationError,
  RoundoffError,
  DiscretisationError,
  IterationError
 ]

 STOP_CONDITION =
  "Stop when problem structure, algorithm, discretisation, conditioning, error, convergence, complexity, reproducibility, verification and validation are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics"

 IMMEDIATE_CONTEXTS = [
  "Computational Mathematics",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies",
  "Linear Algebra Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Computational Mathematics",
  "Applied Mathematics Ontologies",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies",
  "Linear Algebra Ontologies",
  "Optimisation Ontologies",
  "Differential Equation Ontologies",
  "Discrete Mathematics Ontologies",
  "Probability & Statistics Ontologies",
  "Symbolic Computation Ontologies",
  "Algorithmic Complexity Ontologies",
  "High Performance Computing Ontologies",
  "Uncertainty Quantification Ontologies"
 ]

 ROUTE_RULES = [
  "Computational Mathematics Ontology -> Computational Mathematics for parent semantics",
  "Computational Mathematics Ontology -> Numerical Analysis for error, stability and convergence",
  "Computational Mathematics Ontology -> Scientific Computing for implementation",
  "Computational Mathematics Ontology -> Linear Algebra for matrix algorithms",
  "Computational Mathematics Ontology -> Optimisation for computational search",
  "Computational Mathematics Ontology -> Differential Equations for ODE and PDE solvers",
  "Computational Mathematics Ontology -> Discrete Mathematics for combinatorial algorithms",
  "Computational Mathematics Ontology -> Probability & Statistics for stochastic computation",
  "Computational Mathematics Ontology -> Symbolic Computation for exact manipulation",
  "Computational Mathematics Ontology -> HPC for large-scale parallel computation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible algorithms, computational entities or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve formal algorithmic-computation semantics.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve consistency-and-convergence semantics.",
  "Preserve finite-precision semantics.",
  "Preserve residual-versus-error distinction.",
  "Preserve symbolic-versus-numerical distinction.",
  "Preserve verification-versus-validation distinction.",
  "Preserve machine-readable computational-mathematics ontology semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "The Computational Mathematics Ontology formally represents algorithms, approximations, computational errors, numerical stability, convergence, complexity and validation used in mathematical computation."

 ALGORITHM_SUMMARY =
  "Computational mathematics distinguishes direct, iterative, numerical, symbolic and stochastic algorithms."

 NUMERICAL_QUALITY_SUMMARY =
  "Reliable computation separates problem conditioning from algorithm stability and evaluates residual, error and convergence."

 DISCRETISATION_SUMMARY =
  "Continuous problems are converted into discrete forms through finite-difference, finite-volume, finite-element, spectral and related methods."

 LINEAR_ALGEBRA_SUMMARY =
  "Matrix factorisation, Krylov iteration and preconditioning provide core methods for computational linear algebra."

 SYMBOLIC_SUMMARY =
  "Computer algebra and symbolic algorithms manipulate exact expressions and can complement numerical methods."

 COMPLEXITY_SUMMARY =
  "Algorithmic feasibility depends on arithmetic, memory, communication and parallel scalability."

 TRUST_SUMMARY =
  "Verification checks whether the computational method solves the stated mathematics; validation checks whether the mathematical model is appropriate for the intended problem."
}

FLOW {
 INPUT
 -> detect_computational_mathematics_ontology_context
 -> identify mathematical_problem_equations_objectives_structure_size_accuracy_requirements_precision_and_resources
 -> classify symbolic_numerical_linear_nonlinear_continuous_discrete_deterministic_stochastic_dense_or_sparse problem
 -> assess conditioning
 -> select algorithm_discretisation_data structure_and_solver
 -> compute symbolic_or_numerical result
 -> evaluate residual_truncation_discretisation_iteration_and_roundoff error
 -> test stability_consistency_and_convergence
 -> assess computational complexity_memory_and_parallel scalability
 -> perform reproducibility_and_numerical verification
 -> perform model validation_if_applicable
 -> route to computational_mathematics numerical_analysis scientific_computing linear_algebra optimisation differential_equations discrete_mathematics probability_statistics symbolic_computation algorithmic_complexity HPC_or_uncertainty_quantification ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Computational Mathematics Ontology provides the formal semantic layer beneath computational mathematics. It represents algorithms, numerical and symbolic computation, scientific computing, numerical linear algebra, matrix factorisations, eigenvalue problems, approximation, interpolation and quadrature, root-finding and iterative methods, Krylov solvers and preconditioning, discretisation, meshes and basis functions, finite-difference, finite-volume, finite-element and spectral methods, numerical ODE and PDE solution, stability, consistency, convergence, conditioning, residuals, truncation, discretisation, iteration and roundoff errors, floating-point arithmetic, complexity analysis, Monte Carlo methods, uncertainty quantification, computer algebra, automatic differentiation, parallel computing, high-performance computing, reproducibility, verification and validation."
}

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

}

END_FLOW
Privacy Policy
Site Map
Kireth Research
38 Thorndale Croft, Wetwang, Driffield
East Riding of Yorkshire YO25 9XZ
Telephone:
01377 236594
Designed By
Kireth Web Design
Audio Explainer RSS Feed