Numerical Methods Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Methods Ontology 2 within the Kireth Research Semantic Library. It formalises the core computational techniques used to approximate mathematical solutions through finite algorithms. This ontology supports root finding, linear and nonlinear systems, numerical differentiation and integration, interpolation, approximation, eigenvalue problems, numerical ordinary and partial differential equations, optimisation, adaptive methods, floating-point computation, error analysis, conditioning, stability, convergence and verification.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = NumericalMethodsOntology
 ENTITY_CLASS = CoreNumericalAlgorithmFramework
 PRIMARY_CONTEXT = NumericalMethods
 DEFINITION = "The Numerical Methods Ontology formalises the principal finite computational procedures used to approximate mathematical quantities, equations and models."
 SYMBOLIC_FORMS = [
  "x_(k+1)=F(x_k)",
  "A x=b",
  "I approximately Q_h(f)",
  "u_h approximates u"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for numerical algorithms, approximation, discretisation, finite precision, error, conditioning, stability, convergence, adaptivity and computational verification."
}

SCOPE {
 INCLUDE = [
  NumericalMethodsOntology,
  NumericalMethod,
  NumericalAlgorithm,
  ApproximateSolution,
  NumericalApproximation,
  DirectMethod,
  IterativeMethod,
  FixedPointIteration,
  RootFinding,
  BisectionMethod,
  RegulaFalsiMethod,
  SecantMethod,
  NewtonMethod,
  NewtonRaphsonMethod,
  BracketingMethod,
  OpenMethod,
  NonlinearEquation,
  NonlinearSystem,
  LinearSystem,
  Matrix,
  SparseMatrix,
  GaussianElimination,
  LUDecomposition,
  QRDecomposition,
  CholeskyDecomposition,
  IterativeLinearSolver,
  JacobiMethod,
  GaussSeidelMethod,
  SuccessiveOverRelaxation,
  SOR,
  KrylovMethod,
  ConjugateGradientMethod,
  GMRES,
  Preconditioner,
  EigenvalueProblem,
  EigenvectorProblem,
  PowerMethod,
  InverseIteration,
  RayleighQuotientIteration,
  NumericalDifferentiation,
  ForwardDifference,
  BackwardDifference,
  CentralDifference,
  HigherOrderDifference,
  NumericalIntegration,
  Quadrature,
  RectangleRule,
  MidpointRule,
  TrapezoidalRule,
  SimpsonRule,
  GaussianQuadrature,
  AdaptiveQuadrature,
  MonteCarloIntegration,
  Interpolation,
  LinearInterpolation,
  PolynomialInterpolation,
  LagrangeInterpolation,
  NewtonInterpolation,
  SplineInterpolation,
  CubicSpline,
  HermiteInterpolation,
  Extrapolation,
  RichardsonExtrapolation,
  RombergIntegration,
  ApproximationTheory,
  PolynomialApproximation,
  LeastSquaresApproximation,
  SpectralApproximation,
  NumericalODE,
  InitialValueProblem,
  BoundaryValueProblem,
  EulerMethod,
  ImprovedEulerMethod,
  HeunMethod,
  RungeKuttaMethod,
  RungeKuttaFourthOrder,
  MultistepMethod,
  AdamsBashforthMethod,
  AdamsMoultonMethod,
  PredictorCorrectorMethod,
  BackwardDifferentiationFormula,
  StiffEquation,
  ImplicitMethod,
  ExplicitMethod,
  NumericalPDE,
  EllipticPDE,
  ParabolicPDE,
  HyperbolicPDE,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeMethod,
  SpectralMethod,
  BoundaryElementMethod,
  MethodOfLines,
  ComputationalOptimisation,
  GradientDescent,
  NewtonOptimisation,
  QuasiNewtonMethod,
  TrustRegionMethod,
  LineSearch,
  ConstrainedOptimisation,
  UnconstrainedOptimisation,
  Discretisation,
  Mesh,
  Grid,
  StepSize,
  TimeStep,
  SpatialStep,
  AdaptiveMethod,
  AdaptiveStepSize,
  AdaptiveMesh,
  Refinement,
  ErrorEstimator,
  APosterioriErrorEstimator,
  FloatingPointArithmetic,
  MachinePrecision,
  MachineEpsilon,
  RoundoffError,
  TruncationError,
  DiscretisationError,
  IterationError,
  AbsoluteError,
  RelativeError,
  ForwardError,
  BackwardError,
  Residual,
  Conditioning,
  ConditionNumber,
  Stability,
  NumericalStability,
  Consistency,
  Convergence,
  ConvergenceRate,
  LinearConvergence,
  SuperlinearConvergence,
  QuadraticConvergence,
  Tolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  StoppingCriterion,
  Verification,
  Benchmarking,
  ReferenceSolution,
  Reproducibility
 ]
 EXCLUDE_AS_PRIMARY = [
  SymbolicComputationWithoutNumericalApproximation,
  PureAnalyticalSolutionWithoutNumericalMethod,
  SoftwareEngineeringWithoutMathematicalNumerics,
  ExperimentalMeasurementWithoutNumericalModel
 ]
 DISAMBIGUATION_RULE = "When a finite numerical procedure approximates a mathematical quantity, equation or model and error or convergence matters, interpret the context as a numerical method."
}

CORE_CONCEPTS {
 NumericalMethodsOntology = "Formal ontology of principal numerical algorithms and approximation methods."
 NumericalMethod = "Finite computational procedure used to approximate a mathematical target."
 ApproximateSolution = "Numerical estimate of an exact or ideal mathematical solution."
 IterativeMethod = "Procedure that repeatedly updates an approximation."
 DirectMethod = "Procedure intended to obtain a solution through a finite algebraic process under finite precision."
 Discretisation = "Finite representation of a continuous mathematical problem."
 Conditioning = "Sensitivity of the mathematical problem to perturbations."
 Stability = "Sensitivity of the numerical method to perturbations and arithmetic error."
 Convergence = "Approach of numerical approximations to the target solution."
 ErrorEstimator = "Computed quantity estimating numerical approximation error."
}

RELATIONS {
 NumericalMethodsOntology --is_child_of--> NumericalMethods
 NumericalMethod --produces--> ApproximateSolution
 IterativeMethod --uses--> StoppingCriterion
 RootFinding --solves--> NonlinearEquation
 GaussianElimination --solves--> LinearSystem
 LUDecomposition --factorises--> Matrix
 ConjugateGradientMethod --solves--> SymmetricPositiveDefiniteSystem
 GMRES --solves--> GeneralNonsymmetricLinearSystem
 Preconditioner --improves--> IterativeConvergence
 NumericalDifferentiation --approximates--> Derivative
 NumericalIntegration --approximates--> Integral
 Interpolation --approximates--> FunctionBetweenKnownValues
 NumericalODE --approximates--> ODESolution
 NumericalPDE --approximates--> PDESolution
 FiniteDifferenceMethod --discretises--> DifferentialEquation
 FiniteElementMethod --discretises--> VariationalProblem
 FiniteVolumeMethod --discretises--> ConservationLaw
 SpectralMethod --uses--> GlobalBasisFunctions
 ErrorEstimator --guides--> AdaptiveMethod
 Conditioning --describes--> ProblemSensitivity
 Stability --describes--> MethodSensitivity
 Consistency --supports--> Convergence
 Verification --checks--> NumericalImplementation
}

OPERATORS {
 ABSOLUTE_ERROR(x_exact,x_approx) := |x_exact-x_approx|
 RELATIVE_ERROR(x_exact,x_approx) := |x_exact-x_approx|/|x_exact|
 RESIDUAL(A,x,b) := r=b-A*x
 CONDITION_NUMBER(A) := kappa(A)=||A||*||A^(-1)||
 FIXED_POINT(x,g) := x_next=g(x)
 NEWTON_ROOT(x,f) := x_next=x-f(x)/f'(x)
 SECANT_ROOT(x0,x1,f) := x_next=x1-f(x1)*(x1-x0)/(f(x1)-f(x0))
 BISECTION_STEP(a,b) := midpoint=(a+b)/2
 FORWARD_DIFFERENCE(f,x,h) := (f(x+h)-f(x))/h
 BACKWARD_DIFFERENCE(f,x,h) := (f(x)-f(x-h))/h
 CENTRAL_DIFFERENCE(f,x,h) := (f(x+h)-f(x-h))/(2*h)
 TRAPEZOID_RULE(f,a,b) := (b-a)*(f(a)+f(b))/2
 SIMPSON_RULE(f,a,b) := (b-a)*(f(a)+4*f((a+b)/2)+f(b))/6
 EULER_STEP(y,t,h,f) := y_next=y+h*f(t,y)
 RK4_STEP(y,t,h,f) := weighted_four_stage_Runge_Kutta_update
}

AXIOMS {
 A1 = "Numerical methods generally produce approximations under finite arithmetic."
 A2 = "Approximate results require explicit error semantics."
 A3 = "Conditioning belongs to the mathematical problem, while stability belongs to the numerical method."
 A4 = "Convergence requires a declared limiting process."
 A5 = "Discretisation parameters affect accuracy, stability and computational cost."
 A6 = "Iterative methods require explicit stopping criteria."
 A7 = "Adaptive methods require reliable error estimators."
 A8 = "Numerical results require verification and reproducibility where applicable."
}

REASONING {
 R1_CONTEXT = identify(problem_type,target_quantity,dimension,precision,accuracy_goal)
 R2_CLASS = classify(root,linear_system,eigenvalue,derivative,integral,interpolation,ODE,PDE_or_optimisation)
 R3_METHOD = select(direct,iterative,explicit,implicit,adaptive,spectral_or_discretisation_method)
 R4_CONDITIONING = analyse(problem_sensitivity)
 R5_STABILITY = analyse(method_stability_and_roundoff_growth)
 R6_ERROR = estimate(roundoff,truncation,discretisation,iteration_and_total_error)
 R7_CONVERGENCE = determine(rate,tolerance,stopping_criterion)
 R8_ADAPTIVITY = refine(step_size,mesh,quadrature_order_or_iteration_if_required)
 R9_EFFICIENCY = assess(operation_count,memory,sparsity_and_solver_cost)
 R10_VALIDATION = compare(reference_solution,residual,error_bounds,refinement_and_reproducibility)
}

CONSTRAINTS {
 C1 = "Smaller step sizes do not always reduce total error because roundoff can dominate."
 C2 = "A small residual does not necessarily imply small forward error for ill-conditioned problems."
 C3 = "Newton-type methods can fail without suitable initialisation or derivative behaviour."
 C4 = "Bracketing methods require valid bracketing conditions."
 C5 = "Explicit time-stepping methods can become unstable when stability restrictions are violated."
 C6 = "Iterative linear solvers depend on matrix spectrum and preconditioning."
 C7 = "Numerical differentiation amplifies noise."
 C8 = "High-order interpolation can oscillate on unsuitable nodes."
 C9 = "Quadrature accuracy depends on integrand smoothness and singularities."
 C10 = "Benchmark agreement does not prove correctness outside the tested regime."
}

SEMANTIC_EQUIVALENCE {
 "NumericalMethodsOntology" <=> "CoreNumericalMethodsOntology"
 "NewtonMethod" <=> "NewtonRaphsonMethod"
 "SuccessiveOverRelaxation" <=> "SOR"
 "FiniteDifferenceMethod" <=> "FDM"
 "FiniteElementMethod" <=> "FEM"
 "FiniteVolumeMethod" <=> "FVM"
}

VALIDATION {
 V1 = "Numerical problem and target quantity are explicit."
 V2 = "Precision model and representation are documented."
 V3 = "Conditioning is assessed where relevant."
 V4 = "Error sources are identified."
 V5 = "Stability is assessed."
 V6 = "Convergence is demonstrated or justified."
 V7 = "Stopping criteria and tolerances are explicit."
 V8 = "Adaptive refinement uses documented error criteria."
 V9 = "Reference or benchmark solutions are used where feasible."
 V10 = "Results are reproducible under documented numerical settings."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_METHODS_ONTOLOGY_DEFINITION = 0.99
 ROOT_FINDING_REASONING = 0.99
 LINEAR_SOLVER_REASONING = 0.99
 EIGENVALUE_REASONING = 0.98
 DIFFERENTIATION_REASONING = 0.99
 QUADRATURE_REASONING = 0.99
 ODE_REASONING = 0.99
 PDE_REASONING = 0.98
 ERROR_ANALYSIS_REASONING = 0.99
 POLICY = "Reduce confidence when numerical method, precision, discretisation, conditioning, tolerance, step size, mesh, initial guess or convergence regime are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  NumericalMethodsOntologyReasoning,
  RootFindingReasoning,
  NumericalLinearAlgebraReasoning,
  EigenvalueReasoning,
  NumericalDifferentiationReasoning,
  NumericalIntegrationReasoning,
  InterpolationReasoning,
  ApproximationReasoning,
  NumericalODEReasoning,
  NumericalPDEReasoning,
  FiniteDifferenceReasoning,
  FiniteElementReasoning,
  FiniteVolumeReasoning,
  SpectralMethodReasoning,
  NumericalOptimisationReasoning,
  ErrorAnalysisReasoning,
  StabilityReasoning,
  ConvergenceReasoning,
  AdaptiveMethodReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]
 NORMALISE {
  "numerical methods ontology" -> NumericalMethodsOntology
  "numerical methods" -> NumericalMethods
  "Newton-Raphson" -> NewtonMethod
  "SOR" -> SuccessiveOverRelaxation
  "FDM" -> FiniteDifferenceMethod
  "FEM" -> FiniteElementMethod
  "FVM" -> FiniteVolumeMethod
 }
}

EXECUTION_RULES {
 E1 = "If a mathematical problem is approximated through finite numerical procedures, activate NumericalMethodsOntology."
 E2 = "If a nonlinear scalar equation is solved, route to root-finding methods."
 E3 = "If matrix systems or eigenproblems dominate, route to numerical linear algebra."
 E4 = "If derivatives or integrals are approximated, route to numerical differentiation or quadrature."
 E5 = "If functions are reconstructed from known values, route to interpolation or approximation."
 E6 = "If an ODE is solved numerically, route to one-step, multistep, explicit or implicit ODE methods."
 E7 = "If a PDE is discretised, route to finite difference, finite element, finite volume, spectral or related methods."
 E8 = "If accuracy is insufficient, use adaptive refinement when appropriate."
 E9 = "Any numerical method should be validated for conditioning, stability, error, convergence and reproducibility."
}

RECURSION {
 ENTRY = NumericalMethodsOntology
 EXPAND(NumericalMethodsOntology) -> [
  NumericalMethod, NumericalAlgorithm, ApproximateSolution,
  NumericalApproximation, DirectMethod, IterativeMethod,
  FixedPointIteration, RootFinding, BisectionMethod, RegulaFalsiMethod,
  SecantMethod, NewtonMethod, BracketingMethod, OpenMethod,
  NonlinearEquation, NonlinearSystem, LinearSystem, Matrix, SparseMatrix,
  GaussianElimination, LUDecomposition, QRDecomposition,
  CholeskyDecomposition, IterativeLinearSolver, JacobiMethod,
  GaussSeidelMethod, SuccessiveOverRelaxation, KrylovMethod,
  ConjugateGradientMethod, GMRES, Preconditioner, EigenvalueProblem,
  PowerMethod, InverseIteration, RayleighQuotientIteration,
  NumericalDifferentiation, ForwardDifference, BackwardDifference,
  CentralDifference, HigherOrderDifference, NumericalIntegration,
  Quadrature, RectangleRule, MidpointRule, TrapezoidalRule,
  SimpsonRule, GaussianQuadrature, AdaptiveQuadrature,
  MonteCarloIntegration, Interpolation, LinearInterpolation,
  PolynomialInterpolation, LagrangeInterpolation, NewtonInterpolation,
  SplineInterpolation, CubicSpline, HermiteInterpolation, Extrapolation,
  RichardsonExtrapolation, RombergIntegration, ApproximationTheory,
  PolynomialApproximation, LeastSquaresApproximation,
  SpectralApproximation, NumericalODE, InitialValueProblem,
  BoundaryValueProblem, EulerMethod, ImprovedEulerMethod, HeunMethod,
  RungeKuttaMethod, RungeKuttaFourthOrder, MultistepMethod,
  AdamsBashforthMethod, AdamsMoultonMethod, PredictorCorrectorMethod,
  BackwardDifferentiationFormula, StiffEquation, ImplicitMethod,
  ExplicitMethod, NumericalPDE, EllipticPDE, ParabolicPDE,
  HyperbolicPDE, FiniteDifferenceMethod, FiniteElementMethod,
  FiniteVolumeMethod, SpectralMethod, BoundaryElementMethod,
  MethodOfLines, ComputationalOptimisation, GradientDescent,
  NewtonOptimisation, QuasiNewtonMethod, TrustRegionMethod,
  LineSearch, ConstrainedOptimisation, UnconstrainedOptimisation,
  Discretisation, Mesh, Grid, StepSize, TimeStep, SpatialStep,
  AdaptiveMethod, AdaptiveStepSize, AdaptiveMesh, Refinement,
  ErrorEstimator, APosterioriErrorEstimator, FloatingPointArithmetic,
  MachinePrecision, MachineEpsilon, RoundoffError, TruncationError,
  DiscretisationError, IterationError, AbsoluteError, RelativeError,
  ForwardError, BackwardError, Residual, Conditioning, ConditionNumber,
  Stability, NumericalStability, Consistency, Convergence,
  ConvergenceRate, LinearConvergence, SuperlinearConvergence,
  QuadraticConvergence, Tolerance, AbsoluteTolerance, RelativeTolerance,
  StoppingCriterion, Verification, Benchmarking, ReferenceSolution,
  Reproducibility
 ]
 EXPAND(MethodFamilies) -> [
  RootFindingMethods,
  NumericalLinearAlgebraMethods,
  EigenvalueMethods,
  NumericalDifferentiationMethods,
  NumericalIntegrationMethods,
  InterpolationAndApproximationMethods,
  NumericalODEMethods,
  NumericalPDEMethods,
  NumericalOptimisationMethods,
  AdaptiveNumericalMethods
 ]
 STOP_CONDITION = "Stop when problem class, numerical method, representation, error, stability, convergence, tolerance and verification are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Numerical Methods"
 RELATED_ONTOLOGIES = [
  "Numerical Methods",
  "Computational Mathematics Ontologies",
  "Foundations of Computational Mathematics",
  "Numerical Computation Ontology",
  "Scientific Computing Ontology 2",
  "Numerical Analysis Ontologies",
  "Numerical Linear Algebra Ontologies",
  "Approximation Theory Ontologies",
  "Differential Equation Ontologies",
  "Optimisation Ontologies"
 ]
 ROUTE_RULES = [
  "Numerical Methods Ontology 2 -> Numerical Methods for parent semantics",
  "Numerical Methods Ontology 2 -> Computational Mathematics Ontologies for broader computational context",
  "Numerical Methods Ontology 2 -> Foundations of Computational Mathematics for foundational error and stability semantics",
  "Numerical Methods Ontology 2 -> Numerical Computation for finite-precision computation",
  "Numerical Methods Ontology 2 -> Scientific Computing for scientific-model application",
  "Numerical Methods Ontology 2 -> Numerical Analysis for formal stability and convergence",
  "Numerical Methods Ontology 2 -> Numerical Linear Algebra for matrix and eigenvalue computation",
  "Numerical Methods Ontology 2 -> Approximation Theory for interpolation and approximation",
  "Numerical Methods Ontology 2 -> Differential Equations for numerical ODE and PDE solving",
  "Numerical Methods Ontology 2 -> Optimisation for numerical optimisation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible numerical algorithms, discretisations or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve exact-versus-approximate distinction.",
  "Preserve direct-versus-iterative method distinction.",
  "Preserve conditioning-versus-stability distinction.",
  "Preserve residual-versus-error distinction.",
  "Preserve explicit-versus-implicit distinction.",
  "Preserve fixed-versus-adaptive distinction.",
  "Preserve ODE-versus-PDE numerical distinction.",
  "Preserve machine-readable numerical-methods semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "The Numerical Methods Ontology formalises finite computational techniques for approximating mathematical quantities and solutions."
 ROOT_SUMMARY = "Bisection, regula falsi, secant and Newton methods solve nonlinear equations under different robustness and convergence assumptions."
 LINEAR_SUMMARY = "Direct and iterative linear-algebra methods solve dense, sparse and structured matrix systems."
 EIGENVALUE_SUMMARY = "Power, inverse and Rayleigh-quotient iteration approximate dominant or selected eigenpairs."
 APPROXIMATION_SUMMARY = "Finite differences, quadrature, interpolation, splines and extrapolation approximate derivatives, integrals and functions."
 ODE_SUMMARY = "Euler, Runge-Kutta and multistep methods approximate ordinary differential equations."
 PDE_SUMMARY = "Finite-difference, finite-element, finite-volume and spectral methods discretise partial differential equations."
 VALIDATION_SUMMARY = "Numerical methods should be checked for conditioning, stability, error, convergence, tolerance adequacy and reproducibility."
}

FLOW {
 INPUT
 -> detect_numerical_methods_ontology_context
 -> identify_problem_class_target_quantity_dimension_precision_and_accuracy_goal
 -> select_root_finding_linear_algebra_eigenvalue_differentiation_integration_interpolation_ODE_PDE_or_optimisation_family
 -> choose_direct_iterative_explicit_implicit_fixed_step_adaptive_or_discretised_method
 -> analyse_conditioning_and_stability
 -> estimate_roundoff_truncation_discretisation_iteration_and_total_error
 -> assess_convergence_rate_tolerance_and_stopping_criterion
 -> refine_step_size_mesh_order_preconditioner_or_iteration_if_required
 -> verify_against_residuals_error_bounds_reference_solutions_or_benchmarks
 -> route_to_numerical_methods_computational_mathematics_foundations_numerical_computation_scientific_computing_numerical_analysis_linear_algebra_approximation_differential_equations_or_optimisation_ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Numerical Methods Ontology 2 formalises the core numerical methods used throughout computational mathematics. It supports root finding and fixed-point methods, nonlinear systems, dense and sparse linear systems, Gaussian elimination and LU, QR and Cholesky decomposition, Jacobi, Gauss-Seidel, SOR, Krylov, conjugate-gradient and GMRES methods, preconditioning, eigenvalue iterations, forward, backward, central and higher-order differences, numerical integration, rectangle, midpoint, trapezoidal, Simpson and Gaussian quadrature, adaptive quadrature and Monte Carlo integration, linear, polynomial, Lagrange, Newton, Hermite and spline interpolation, Richardson extrapolation and Romberg integration, approximation theory, numerical ODE methods including Euler, Heun, Runge-Kutta, multistep, predictor-corrector and backward-differentiation schemes, numerical PDE methods including finite difference, finite element, finite volume, spectral, boundary-element and method-of-lines formulations, numerical optimisation, meshes, grids and adaptive refinement, finite-precision arithmetic, error, conditioning, stability, consistency, convergence, tolerances, verification, benchmarking and reproducibility."
}

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

}

END_FLOW