Numerical Verification Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Numerical Verification Ontology within the Kireth Research Semantic Library. Numerical verification concerns establishing that a numerical method, discretisation and computed solution are implemented and resolved correctly relative to the governing mathematical problem. This ontology supports residual analysis, discretisation error, truncation error, iterative error, round-off error, convergence studies, mesh and time-step refinement, observed order of accuracy, Richardson extrapolation, method of manufactured solutions, benchmark comparison, solver tolerance studies, conditioning, stability, uncertainty, acceptance criteria and reproducibility.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Numerical Verification Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Verification & Validation / Numerical Verification"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/verification-validation/numerical-verification-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = NumericalVerification
 ENTITY_CLASS = NumericalCorrectnessAssessmentFramework
 PRIMARY_CONTEXT = VerificationValidation
 DEFINITION = "Numerical verification is the process of assessing whether a numerical method and computed solution correctly approximate the governing mathematical equations within declared discretisation, iterative and floating-point error limits."
 SYMBOLIC_FORMS = [
  "residual = F_h(u_h)",
  "error_h = u_h-u_exact",
  "p_obs = log(e_h/e_h2)/log(r)",
  "u_exact ≈ u_h + (u_h-u_h2)/(r^p-1)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for numerical error decomposition, residuals, convergence, refinement, observed order, manufactured solutions, solver tolerance, stability and reproducibility."
}

SCOPE {
 INCLUDE = [
  NumericalVerification,
  Verification,
  ComputationalVerification,
  SolutionVerification,
  NumericalCorrectness,
  NumericalAccuracy,
  NumericalError,
  TotalNumericalError,
  DiscretisationError,
  TruncationError,
  LocalTruncationError,
  GlobalTruncationError,
  IterationError,
  AlgebraicError,
  SolverError,
  RoundOffError,
  FloatingPointError,
  ApproximationError,
  ProjectionErrorRelationship,
  InterpolationErrorRelationship,
  QuadratureErrorRelationship,
  TemporalDiscretisationError,
  SpatialDiscretisationError,
  Residual,
  ResidualVector,
  RelativeResidual,
  NormalisedResidual,
  BackwardError,
  ForwardError,
  AbsoluteError,
  RelativeError,
  NormwiseError,
  ComponentwiseError,
  ErrorNorm,
  L1Error,
  L2Error,
  InfinityNormError,
  EnergyNormRelationship,
  ExactSolution,
  AnalyticalSolution,
  ReferenceSolution,
  ManufacturedSolution,
  MethodOfManufacturedSolutions,
  MMS,
  BenchmarkProblem,
  KnownAnswerTest,
  ReferenceImplementation,
  IndependentImplementation,
  Mesh,
  Grid,
  SpatialGrid,
  ComputationalMesh,
  StructuredMeshRelationship,
  UnstructuredMeshRelationship,
  MeshSize,
  GridSpacing,
  CharacteristicMeshSize,
  TimeStep,
  StepSize,
  Resolution,
  Refinement,
  GridRefinement,
  MeshRefinement,
  TimeStepRefinement,
  UniformRefinement,
  AdaptiveRefinementRelationship,
  RefinementRatio,
  ConvergenceStudy,
  GridConvergence,
  MeshConvergence,
  TimeStepConvergence,
  ResolutionConvergence,
  IterativeConvergence,
  SolverConvergence,
  AsymptoticConvergenceRange,
  OrderOfAccuracy,
  FormalOrderOfAccuracy,
  ObservedOrderOfAccuracy,
  ConvergenceRate,
  ExperimentalOrderOfConvergenceRelationship,
  RichardsonExtrapolation,
  ExtrapolatedSolution,
  GridConvergenceIndex,
  GCI,
  DiscretisationUncertaintyRelationship,
  MeshIndependence,
  GridIndependence,
  TimeStepIndependence,
  ResolutionIndependence,
  IndependenceStudy,
  SolverTolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  ResidualTolerance,
  NonlinearTolerance,
  LinearSolverTolerance,
  IterationLimit,
  StoppingCriterion,
  ToleranceStudy,
  ToleranceSensitivity,
  LinearSolver,
  NonlinearSolver,
  IterativeSolver,
  DirectSolverRelationship,
  DifferentialEquationSolver,
  OrdinaryDifferentialEquationSolver,
  PartialDifferentialEquationSolver,
  FiniteDifferenceMethod,
  FiniteElementMethod,
  FiniteVolumeRelationship,
  BoundaryElementMethod,
  SpectralMethod,
  NumericalIntegration,
  Quadrature,
  NumericalDifferentiation,
  NumericalLinearAlgebra,
  ComputationalOptimisation,
  Stability,
  NumericalStability,
  Consistency,
  ConvergenceTheoremRelationship,
  LaxEquivalenceRelationship,
  Conditioning,
  ConditionNumber,
  IllConditioning,
  PerturbationAnalysis,
  SensitivityAnalysis,
  Stiffness,
  CFLConditionRelationship,
  CourantNumberRelationship,
  StabilityLimit,
  RoundOffDominatedRegime,
  DiscretisationDominatedRegime,
  IterationDominatedRegime,
  ErrorBalance,
  ErrorBudget,
  ErrorPropagation,
  APosterioriErrorEstimate,
  APrioriErrorEstimate,
  Uncertainty,
  NumericalUncertainty,
  DiscretisationUncertainty,
  SolverUncertaintyRelationship,
  FloatingPointUncertaintyRelationship,
  BoundaryCondition,
  InitialCondition,
  SourceTerm,
  GoverningEquation,
  DifferentialOperator,
  AlgebraicSystem,
  WeakFormRelationship,
  StrongFormRelationship,
  ConservationLaw,
  Constraint,
  Invariant,
  ConservationCheck,
  MassBalance,
  EnergyBalance,
  MomentumBalance,
  SymmetryCheck,
  PositivityCheck,
  MonotonicityCheck,
  BoundaryConditionCheck,
  InitialConditionCheck,
  ConstraintCheck,
  ConsistencyCheck,
  RegressionTest,
  UnitTest,
  IntegrationTest,
  BenchmarkTest,
  VerificationTestSuite,
  AcceptanceCriterion,
  VerificationCriterion,
  PassCriterion,
  FailCriterion,
  ErrorThreshold,
  ConfidenceLevelRelationship,
  FloatingPointArithmetic,
  MachinePrecision,
  MixedPrecision,
  SinglePrecision,
  DoublePrecision,
  Reproducibility,
  Repeatability,
  RandomSeed,
  Determinism,
  Nondeterminism,
  Provenance,
  ComputationalProvenance,
  MeshVersion,
  SolverVersion,
  MethodVersion,
  LibraryVersion,
  CompilerVersion,
  HardwareVersionRelationship,
  ImplementationVersion,
  Configuration,
  SolverConfiguration,
  PrecisionConfiguration,
  ToleranceConfiguration,
  VerificationProtocol,
  TestProtocol,
  Documentation,
  Traceability,
  Evidence,
  VerificationEvidence,
  ReferenceData,
  BenchmarkData
 ]
 EXCLUDE_AS_PRIMARY = [
  ModelValidationWhenAgreementWithPhysicalOrExperimentalRealityIsPrimary,
  SoftwareUnitTestingWithoutNumericalMethodCorrectnessContext,
  PureErrorEstimationWithoutVerificationDecisionSemantics,
  FormalProofWithoutNumericalApproximationContext
 ]
 DISAMBIGUATION_RULE = "When the correctness and numerical accuracy of a discretised or iterative computational solution are being assessed against governing equations, refinement behaviour or trusted references, interpret the context as numerical verification."
}

CORE_CONCEPTS {
 NumericalVerification = "Assessment of numerical-method and numerical-solution correctness."
 Residual = "Measure of how closely a computed solution satisfies the discrete or continuous governing equations."
 Discretisation-Error = "Error introduced by replacing a continuous mathematical problem with a discrete approximation."
 Iteration-Error = "Error remaining because an iterative solver has not fully converged."
 RoundOffError = "Error introduced by finite-precision arithmetic."
 ConvergenceStudy = "Systematic refinement analysis used to determine whether numerical solutions approach a limiting value."
 ObservedOrderOfAccuracy = "Empirically measured rate at which error decreases under refinement."
 ManufacturedSolution = "Chosen exact solution used to construct a forcing term for code verification."
}

RELATIONS {
 NumericalVerification --is_child_of--> VerificationValidation
 NumericalVerification --uses--> ResidualAnalysis
 NumericalVerification --quantifies--> NumericalError
 DiscretisationError --decreases_with--> ConsistentRefinement
 IterationError --depends_on--> SolverTolerance
 RoundOffError --depends_on--> FloatingPointArithmetic
 ConvergenceStudy --uses--> MultipleResolutions
 ObservedOrderOfAccuracy --compares_to--> FormalOrderOfAccuracy
 RichardsonExtrapolation --estimates--> LimitingSolution
 GridConvergenceIndex --estimates--> DiscretisationUncertainty
 MethodOfManufacturedSolutions --supports--> CodeVerification
 VerificationEvidence --supports--> NumericalVerificationConclusion
}

OPERATORS {
 RESIDUAL(F_h,u_h) := F_h(u_h)
 ABS_ERROR(u_h,u_ref) := abs(u_h-u_ref)
 REL_ERROR(u_h,u_ref) := abs(u_h-u_ref)/max(abs(u_ref),epsilon)
 OBSERVED_ORDER(e1,e2,r) := log(e1/e2)/log(r)
 RICHARDSON(u1,u2,r,p) := u1 + (u1-u2)/(r^p-1)
 GCI_APPROX(ea,r,p,Fs) := Fs*ea/(r^p-1)
 ACCEPT(metric,tolerance) := metric <= tolerance
}

AXIOMS {
 A1 = "Numerical verification concerns numerical correctness, not physical-model validity."
 A2 = "A converged iterative solver can still converge to an insufficiently resolved discretised solution."
 A3 = "A fine mesh alone does not prove asymptotic convergence."
 A4 = "Observed order should be compared with formal method order only within an appropriate asymptotic range."
 A5 = "Residual reduction and solution-error reduction are related but not identical."
 A6 = "Round-off, discretisation and iteration errors can dominate in different regimes."
 A7 = "Verification requires declared metrics, tolerances and trusted references or convergence evidence."
 A8 = "Numerical-verification conclusions require explicit method, resolution, solver tolerance, precision and provenance semantics."
}

REASONING {
 R1_CONTEXT = identify(governing_equations,numerical_method,implementation,resolution,solver_tolerances,precision,reference_options)
 R2_ERRORS = classify(discretisation,iteration,roundoff,approximation_and_other_numerical_errors)
 R3_REFERENCE = choose(analytical,manufactured,benchmark,independent_or_extrapolated_reference)
 R4_RESIDUAL = evaluate_equation_constraint_and_solver_residuals)
 R5_REFINEMENT = design_mesh_grid_time_step_or_tolerance_refinement_study)
 R6_ORDER = compute_observed_order_and_compare_with_theoretical_order)
 R7_EXTRAPOLATE = if_applicable_apply_Richardson_or_GCI_methods)
 R8_STABILITY = assess_conditioning_stability_and_roundoff_sensitivity)
 R9_ACCEPT = compare_metrics_with_verification_criteria_and_document_failures)
 R10_REPRODUCE = record_method_mesh_solver_tolerances_precision_versions_and_provenance)
}

CONSTRAINTS {
 C1 = "A low residual does not necessarily imply a low solution error."
 C2 = "Observed order can be misleading outside the asymptotic convergence range."
 C3 = "Refinement studies require comparable solutions and consistent problem definitions."
 C4 = "Changing both mesh and solver settings simultaneously can confound error attribution."
 C5 = "Round-off can dominate after excessive refinement."
 C6 = "Iterative error can mask discretisation convergence if solver tolerances are too loose."
 C7 = "Manufactured solutions verify implementation consistency but do not validate physical-model adequacy."
 C8 = "Benchmark agreement at one resolution does not establish convergence."
 C9 = "Ill-conditioning can amplify small numerical perturbations."
 C10 = "Verification confidence is limited by reference quality and tested parameter range."
}

SEMANTIC_EQUIVALENCE {
 "MethodOfManufacturedSolutions" <=> "MMS"
 "GridConvergenceIndex" <=> "GCI"
 "ExperimentalOrderOfConvergence" <=> "ObservedOrderOfAccuracy"
 "RootMeanSquareError" <=> "RMSE"
}

VALIDATION {
 V1 = "Governing equations and numerical method are documented."
 V2 = "Spatial and temporal resolutions are documented."
 V3 = "Solver tolerances and stopping criteria are documented."
 V4 = "Floating-point precision is documented."
 V5 = "Residuals are reported using declared norms."
 V6 = "At least two and preferably multiple refinement levels are used for convergence analysis."
 V7 = "Observed order is checked against theoretical expectations where applicable."
 V8 = "Reference solutions have documented provenance."
 V9 = "Dominant error sources and failure cases are reported."
 V10 = "Results are reproducible under documented mesh, method, solver, precision and implementation versions."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 NUMERICAL_VERIFICATION_DEFINITION = 0.99
 RESIDUAL_REASONING = 0.99
 CONVERGENCE_STUDY_REASONING = 0.99
 OBSERVED_ORDER_REASONING = 0.99
 RICHARDSON_REASONING = 0.98
 GCI_REASONING = 0.98
 ROUND_OFF_REASONING = 0.98
 POLICY = "Reduce confidence when reference quality, refinement ratio, asymptotic regime, solver tolerance, precision or error decomposition are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,NumericalVerificationReasoning,
  ResidualReasoning,DiscretisationErrorReasoning,
  IterationErrorReasoning,RoundOffErrorReasoning,
  ConvergenceStudyReasoning,GridConvergenceReasoning,
  TimeStepConvergenceReasoning,ObservedOrderReasoning,
  RichardsonExtrapolationReasoning,GCIReasoning,
  ManufacturedSolutionReasoning,SolverToleranceReasoning,
  ConditioningReasoning,NumericalStabilityReasoning,
  AcceptanceCriterionReasoning,ReproducibilityReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "numerical verification" -> NumericalVerification
  "MMS" -> MethodOfManufacturedSolutions
  "GCI" -> GridConvergenceIndex
  "observed order" -> ObservedOrderOfAccuracy
 }
}

EXECUTION_RULES {
 E1 = "If the correctness and numerical accuracy of a computed approximation are being assessed, activate NumericalVerificationOntology."
 E2 = "Separate discretisation, iteration and round-off error sources."
 E3 = "Use analytical, manufactured, benchmark or extrapolated references where appropriate."
 E4 = "Perform refinement studies before claiming mesh, grid or time-step independence."
 E5 = "Compute observed order only from compatible refinement levels."
 E6 = "Tighten solver tolerances enough that iteration error does not contaminate discretisation studies."
 E7 = "Assess conditioning and stability when small perturbations can be amplified."
 E8 = "Compare verification metrics against explicit acceptance criteria."
 E9 = "Document method, resolution, solver tolerances, precision and software versions for reproducibility."
}

RECURSION {
 ENTRY = NumericalVerification
 EXPAND(NumericalVerification) -> [
  Verification,SolutionVerification,NumericalAccuracy,NumericalError,
  DiscretisationError,TruncationError,IterationError,SolverError,
  RoundOffError,Residual,BackwardError,ForwardError,
  AbsoluteError,RelativeError,ErrorNorm,ReferenceSolution,
  AnalyticalSolution,ManufacturedSolution,MethodOfManufacturedSolutions,MMS,
  BenchmarkProblem,KnownAnswerTest,Mesh,Grid,MeshSize,TimeStep,
  Refinement,GridRefinement,MeshRefinement,TimeStepRefinement,
  ConvergenceStudy,GridConvergence,MeshConvergence,TimeStepConvergence,
  AsymptoticConvergenceRange,OrderOfAccuracy,ObservedOrderOfAccuracy,
  RichardsonExtrapolation,GridConvergenceIndex,GCI,
  MeshIndependence,TimeStepIndependence,SolverTolerance,
  ToleranceStudy,NumericalStability,Conditioning,ConditionNumber,
  ErrorBudget,NumericalUncertainty,BoundaryConditionCheck,
  ConservationCheck,RegressionTest,AcceptanceCriterion,
  FloatingPointArithmetic,Reproducibility,Provenance
 ]
 EXPAND(NumericalVerificationFamilies) -> [
  ResidualAndEquationVerification,
  DiscretisationAndTruncationError,
  IterativeAndSolverError,
  FloatingPointAndRoundOffVerification,
  GridMeshAndTimeStepConvergence,
  OrderOfAccuracyAndRichardsonMethods,
  ManufacturedSolutionsAndReferenceBenchmarks,
  AcceptanceReproducibilityAndTraceability
 ]
 STOP_CONDITION = "Stop when error sources, reference evidence, refinement behaviour, solver tolerances, acceptance criteria and reproducibility are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Verification & Validation"
 RELATED_ONTOLOGIES = [
  "Verification & Validation",
  "Numerical Methods Ontology 2",
  "Numerical Stability Ontology 2",
  "Floating Point Arithmetic Ontology",
  "Differential Equation Solver Ontology",
  "Ordinary Differential Equation Solver Ontology",
  "Partial Differential Equation Solver Ontology",
  "Finite Difference Method Ontology",
  "Finite Element Method Ontology",
  "Boundary Element Method Ontology",
  "Spectral Method Ontology 2",
  "Numerical Linear Algebra Ontology 2",
  "Scientific Simulation Ontology",
  "Computational Statistics Ontology"
 ]
 ROUTE_RULES = [
  "Numerical Verification -> Verification & Validation for parent semantics",
  "Numerical Verification -> Numerical Methods for discretisation and truncation-error semantics",
  "Numerical Verification -> Numerical Stability and Floating Point Arithmetic for finite-precision error analysis",
  "Numerical Verification -> Differential Equation Solvers for residual and time-step verification",
  "Numerical Verification -> Finite Difference, Finite Element, Boundary Element and Spectral Method ontologies for method-specific refinement behaviour",
  "Numerical Verification -> Numerical Linear Algebra for residual, conditioning and solver-tolerance semantics",
  "Numerical Verification -> Scientific Simulation for model-execution verification",
  "Numerical Verification -> Computational Statistics for uncertainty estimation and repeated verification evidence"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible verification methods, error measures or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve verification-versus-validation distinction.",
  "Preserve residual-versus-solution-error distinction.",
  "Preserve discretisation-versus-iteration-error distinction.",
  "Preserve formal-order-versus-observed-order distinction.",
  "Preserve refinement-evidence-versus-single-resolution agreement distinction.",
  "Preserve analytical-reference-versus-manufactured-reference distinction.",
  "Preserve numerical-accuracy-versus-floating-point-reproducibility distinction.",
  "Preserve machine-readable numerical-verification semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Numerical verification establishes whether a numerical method and computed solution correctly approximate the governing mathematical equations within declared numerical error limits."
 ERROR_SUMMARY = "Discretisation, truncation, iteration and round-off errors should be distinguished and controlled separately."
 CONVERGENCE_SUMMARY = "Grid, mesh and time-step refinement studies test whether numerical solutions approach a consistent limiting solution."
 ORDER_SUMMARY = "Observed order of accuracy measures empirical error decay and should be compared with formal method order in the asymptotic regime."
 REFERENCE_SUMMARY = "Analytical, manufactured, benchmark, independent or extrapolated references provide complementary verification evidence."
 VALIDATION_SUMMARY = "Verification conclusions should state residuals, errors, refinement behaviour, solver tolerances, acceptance thresholds and reproducible computational settings."
}

FLOW {
 INPUT
 -> detect_numerical_verification_context
 -> identify_governing_equations_numerical_method_implementation_resolution_solver_tolerances_precision_and_reference_options
 -> classify_discretisation_iteration_roundoff_and_other_error_sources
 -> select_analytical_manufactured_benchmark_independent_or_extrapolated_reference
 -> compute_residuals_errors_and_invariant_checks
 -> design_mesh_grid_time_step_and_solver_tolerance_refinement_studies
 -> estimate_observed_order_and_identify_asymptotic_convergence_range
 -> if_applicable_apply_Richardson_extrapolation_or_GCI
 -> assess_conditioning_stability_and_roundoff_sensitivity
 -> compare_results_with_verification_acceptance_criteria
 -> document_failures_error_budget_method_resolution_tolerances_precision_versions_and_provenance
 -> route_to_related_ontologies
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

FLOW_HASH {
 METHOD = "semantic-content-identity"
 ID = "KIRETH-MATH-VERIFICATION-VALIDATION-NUMERICAL-VERIFICATION-ONTOLOGY-V1"
}

}

END_FLOW