Model Verification Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Model Verification Ontology within the Kireth Research Semantic Library. Model verification is the structured assessment of whether a mathematical or computational model has been implemented, solved and executed correctly relative to its intended equations, algorithms, numerical methods and specifications. This ontology supports code verification, calculation verification, manufactured solutions, benchmark problems, residual checks, conservation checks, convergence studies, discretisation error, solver tolerances, numerical stability, regression testing, reproducibility and relationships with mathematical modelling, computational models, numerical analysis and simulation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = ModelVerification
 ENTITY_CLASS = ModelImplementationCorrectnessFramework
 PRIMARY_CONTEXT = MathematicalModelling
 DEFINITION = "Model verification is the assessment of whether the intended mathematical model has been correctly implemented, solved and executed according to its equations, algorithms and numerical specifications."
 SEMANTIC_ROLE = "Provides the machine-readable framework for code verification, solution verification, numerical error assessment, convergence testing, residual analysis, conservation checks, benchmark comparison and implementation correctness."
}

SCOPE {
 INCLUDE = [
  ModelVerification,
  CodeVerification,
  SolutionVerification,
  CalculationVerification,
  ImplementationVerification,
  AlgorithmVerification,
  NumericalVerification,
  ManufacturedSolution,
  MethodOfManufacturedSolutions,
  AnalyticalSolution,
  BenchmarkProblem,
  ReferenceSolution,
  Residual,
  ConservationCheck,
  ConsistencyCheck,
  ConvergenceStudy,
  GridConvergence,
  MeshConvergence,
  TimeStepConvergence,
  IterativeConvergence,
  DiscretisationError,
  TruncationError,
  RoundoffError,
  IterationError,
  SolverTolerance,
  StabilityCheck,
  RegressionTest,
  UnitTest,
  IntegrationTest,
  Reproducibility,
  NumericalPrecision,
  ErrorEstimate,
  OrderOfAccuracy,
  VerificationStatus,
  VerificationReport
 ]

 EXCLUDE_AS_PRIMARY = [
  ModelValidationAgainstPhysicalReality,
  ParameterCalibration,
  EmpiricalFitAssessment,
  PredictiveGeneralisationAssessmentWithoutImplementationCorrectnessQuestion
 ]

 DISAMBIGUATION_RULE =
  "When the question is whether the intended equations, algorithms or numerical model were implemented and solved correctly, interpret the context as model verification rather than model validation."
}

CORE_CONCEPTS {

 ModelVerification {
  definition = "Assessment of implementation and solution correctness relative to the specified mathematical model."
 }

 CodeVerification {
  definition = "Assessment of whether software correctly implements the intended mathematical equations and algorithms."
 }

 SolutionVerification {
  definition = "Assessment and estimation of numerical error in a specific computed solution."
 }

 ManufacturedSolution {
  definition = "A deliberately chosen exact solution inserted into governing equations to derive compatible source terms for code testing."
 }

 BenchmarkProblem {
  definition = "A problem with a trusted analytical, numerical or community reference solution used for verification."
 }

 Residual {
  definition = "The discrepancy remaining when a computed solution is substituted into the implemented equations."
 }

 ConvergenceStudy {
  definition = "A systematic analysis of solution behaviour under mesh, time-step, iteration or numerical refinement."
 }

 OrderOfAccuracy {
  definition = "The asymptotic rate at which numerical error decreases as discretisation is refined."
 }

 ConservationCheck {
  definition = "Assessment of whether a computation preserves declared conservation laws to the expected tolerance."
 }

 VerificationStatus {
  definition = "A semantic label describing whether implementation and solution correctness are sufficiently supported."
 }
}

RELATIONS {
 ModelVerification --is_part_of--> MathematicalModelling
 ModelVerification --evaluates--> ComputationalModel
 CodeVerification --evaluates--> SoftwareImplementation
 SolutionVerification --evaluates--> NumericalSolution
 ManufacturedSolution --supports--> CodeVerification
 BenchmarkProblem --supports--> ModelVerification
 ReferenceSolution --supports--> ErrorEstimate
 Residual --measures--> EquationSatisfaction
 ConvergenceStudy --estimates--> NumericalError
 GridConvergence --is_special_case_of--> ConvergenceStudy
 TimeStepConvergence --is_special_case_of--> ConvergenceStudy
 IterativeConvergence --is_special_case_of--> ConvergenceStudy
 OrderOfAccuracy --describes--> NumericalMethod
 ConservationCheck --tests--> PhysicalOrMathematicalConstraint
 RegressionTest --protects_against--> ImplementationChangeError
 Reproducibility --supports--> VerificationEvidence
 VerificationStatus --summarises--> VerificationOutcome
}

OPERATORS {
 COMPUTE_RESIDUAL(model,solution) :=
  implemented_equation_residual

 ERROR(reference,approximation,norm) :=
  norm(approximation-reference)

 RELATIVE_ERROR(reference,approximation,norm) :=
  norm(approximation-reference)/norm(reference)
  WHEN norm(reference)!=0

 CONVERGENCE_RATE(e_h,e_h2,r) :=
  log(e_h/e_h2)/log(r)
  under asymptotic_refinement assumptions

 RICHARDSON_EXTRAPOLATION(phi_h,phi_h2,r,p) :=
  phi_h2 + (phi_h2-phi_h)/(r^p-1)

 GRID_CONVERGENCE_INDEX(phi_fine,phi_coarse,r,p,Fs) :=
  Fs*abs(phi_fine-phi_coarse)/(abs(phi_fine)*(r^p-1))
  under declared GCI convention

 CONSERVATION_ERROR(inflow,outflow,storage,source,sink) :=
  balance_residual_under_declared_sign convention

 MANUFACTURED_SOURCE(operator,u_exact) :=
  operator(u_exact)

 CHECK_TOLERANCE(residual,tolerance) :=
  residual <= tolerance

 VERIFY_REGRESSION(current_output,baseline,tolerance) :=
  within_declared_numerical_difference
}

DEFINITIONS {
 D1 = "Verification asks whether the model is implemented and solved correctly."
 D2 = "Validation asks whether the model adequately represents the intended real system."
 D3 = "Code verification focuses on implementation correctness."
 D4 = "Solution verification focuses on numerical error in a computed solution."
 D5 = "Manufactured solutions provide exact-code test cases without requiring physically realistic solutions."
 D6 = "Convergence studies require systematic numerical refinement."
 D7 = "Residual convergence and solution convergence are related but not identical."
 D8 = "Observed order of accuracy should approach theoretical order only in the asymptotic regime."
 D9 = "Solver tolerance must be sufficiently small relative to discretisation error for clean convergence studies."
 D10 = "Passing verification tests does not establish model validity."
}

AXIOMS {
 A1_SPECIFICATION:
  Verification compares implementation against a declared mathematical specification

 A2_CODE_SOLUTION_DISTINCTION:
  Code verification and solution verification are distinct activities

 A3_REFINEMENT:
  Numerical convergence claims require systematic refinement

 A4_REFERENCE:
  Error estimation requires a reference solution, exact solution or convergence-based surrogate

 A5_RESIDUAL:
  Correctly solved discrete equations should satisfy residual tolerances

 A6_CONSERVATION:
  Declared conservation properties should be preserved to expected numerical tolerance

 A7_REPRODUCIBILITY:
  Verification evidence should be reproducible from documented configuration

 A8_VALIDATION_DISTINCTION:
  Verification success does not imply empirical or physical validity
}

REASONING {

 R1_VERIFICATION_PROBLEM_FORMULATION {
  INPUT = model_implementation
  IDENTIFY = mathematical_specification
  IDENTIFY = numerical_method
  IDENTIFY = solver
  IDENTIFY = required_accuracy
  RETURN = verification_plan
 }

 R2_CODE_VERIFICATION {
  INPUT = implementation_and_test_problem
  SELECT = manufactured_solution_analytical_solution_or_benchmark
  RUN = implementation
  COMPARE = computed_and_reference solution
  RETURN = code_verification_result
 }

 R3_MANUFACTURED_SOLUTION {
  INPUT = governing_operator_and_chosen_exact_solution
  DERIVE = compatible_source_terms_and_boundary conditions
  RUN = code
  CHECK = numerical_convergence_to_exact_solution
  RETURN = manufactured_solution_verification
 }

 R4_SOLUTION_VERIFICATION {
  INPUT = production_solution
  IDENTIFY = discretisation_parameters
  COMPUTE = refinement_sequence
  ESTIMATE = numerical_error
  RETURN = solution_verification_profile
 }

 R5_CONVERGENCE_STUDY {
  INPUT = solutions_at_multiple_resolutions
  COMPUTE = solution_differences_or_reference errors
  ESTIMATE = observed_order
  TEST = asymptotic_behaviour
  RETURN = convergence_status
 }

 R6_RESIDUAL_ANALYSIS {
  INPUT = numerical_solution_and_discrete_equations
  COMPUTE = residual_norm
  COMPARE = solver_tolerance
  RETURN = equation_satisfaction_status
 }

 R7_CONSERVATION_CHECK {
  INPUT = model_fluxes_sources_storage_terms
  COMPUTE = balance_error
  COMPARE = expected_tolerance
  RETURN = conservation_status
 }

 R8_REGRESSION_VERIFICATION {
  INPUT = current_and_reference_implementation outputs
  COMPARE = under controlled numerical tolerance
  IDENTIFY = unexpected_changes
  RETURN = regression_status
 }

 R9_ERROR_BUDGET {
  INPUT = numerical_solution
  IDENTIFY = discretisation_iteration_roundoff_sampling_and_solver contributions
  ESTIMATE = dominant_sources
  RETURN = verification_error_budget
 }

 R10_VERIFICATION_REPORTING {
  INPUT = all_verification_evidence
  SUMMARISE = tests_errors_orders_tolerances_failures_and_limitations
  RETURN = verification_report_and_status
 }
}

CONSTRAINTS {
 C1 = "Verification and validation must not be conflated."
 C2 = "Convergence studies need at least a meaningful refinement sequence."
 C3 = "Refinement ratios and norms must be stated."
 C4 = "Observed order estimates are unreliable outside the asymptotic regime."
 C5 = "Iterative error should be small relative to discretisation error in grid studies."
 C6 = "Benchmark agreement may not uniquely prove code correctness."
 C7 = "Manufactured solutions test implementation, not physical realism."
 C8 = "Floating-point differences require tolerance-aware regression tests."
 C9 = "Residual tolerances must account for scaling and conditioning."
 C10 = "Numerical verification evidence is conditional on tested regimes and configurations."
}

SEMANTIC_EQUIVALENCE {
 "ModelVerification" <=> "ImplementationAndSolutionCorrectnessAssessment"
 "CodeVerification" <=> "SoftwareImplementationCorrectnessAssessment"
 "SolutionVerification" <=> "NumericalSolutionErrorAssessment"
 "ManufacturedSolution" <=> "ArtificialExactSolutionForCodeTesting"
 "ConvergenceStudy" <=> "SystematicNumericalRefinementAssessment"
 "VerificationStatus" <=> "ImplementationCorrectnessEvidenceSummary"
}

VALIDATION {
 V1 = "Mathematical specification is identified."
 V2 = "Numerical method and solver are identified."
 V3 = "Reference solution or refinement strategy is appropriate."
 V4 = "Residual tolerance is explicit."
 V5 = "Convergence study uses systematic refinement."
 V6 = "Observed order is interpreted in the asymptotic regime."
 V7 = "Conservation tests use consistent sign and unit conventions."
 V8 = "Regression comparisons use appropriate tolerances."
 V9 = "Verification evidence is reproducible."
 V10 = "Verification conclusions are not presented as validation."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 MODEL_VERIFICATION_DEFINITION = 0.99
 CODE_VERIFICATION_REASONING = 0.99
 SOLUTION_VERIFICATION_REASONING = 0.98
 MANUFACTURED_SOLUTION_REASONING = 0.99
 CONVERGENCE_REASONING = 0.98
 RESIDUAL_REASONING = 0.99
 CONSERVATION_REASONING = 0.98
 REPRODUCIBILITY_REASONING = 0.99

 POLICY =
  "Reduce confidence when mathematical specification, refinement sequence, solver tolerance, reference solution, numerical precision, convergence regime or implementation provenance are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,
  OntologyGrounding,
  ModelVerificationReasoning,
  CodeVerification,
  SolutionVerification,
  ManufacturedSolutionReasoning,
  BenchmarkReasoning,
  ResidualAnalysis,
  ConvergenceAnalysis,
  GridConvergence,
  TimeStepConvergence,
  ErrorEstimation,
  ConservationChecking,
  RegressionTesting,
  ReproducibilityReasoning,
  KnowledgeGraphConstruction,
  RetrievalAugmentation,
  RecursiveInference
 ]

 NORMALISE {
  "model verification" -> ModelVerification
  "code verification" -> CodeVerification
  "solution verification" -> SolutionVerification
  "manufactured solution" -> ManufacturedSolution
  "method of manufactured solutions" -> MethodOfManufacturedSolutions
  "convergence study" -> ConvergenceStudy
  "grid convergence" -> GridConvergence
  "mesh convergence" -> MeshConvergence
  "time-step convergence" -> TimeStepConvergence
  "order of accuracy" -> OrderOfAccuracy
  "regression test" -> RegressionTest
 }

 INTERPRETATION_ORDER = [
  detect_model_verification_context,
  identify mathematical_specification_implementation_numerical_method_solver_and_tolerances,
  identify code_verification_solution_verification_benchmark_residual_convergence_or_conservation goal,
  select exact_reference_manufactured_solution_or_refinement pathway,
  compute errors_residuals_and_orders,
  assess asymptotic_regime_solver_error_and_reproducibility,
  assign verification_status_with_limitations,
  return semantic output
 ]
}

EXECUTION_RULES {
 E1:
  IF query_mentions("model verification")
  OR asks_if_model_was_implemented_or_solved_correctly
  THEN activate(ModelVerificationOntology)

 E2:
  IF code_verification_requested
  THEN prefer exact_manufactured_or_benchmark test problems

 E3:
  IF manufactured_solution_used
  THEN derive compatible_source_and_boundary terms exactly

 E4:
  IF convergence_claim
  THEN require multiple refinement levels

 E5:
  IF observed_order_requested
  THEN verify near_asymptotic behaviour

 E6:
  IF grid_or_time_step study
  THEN ensure iterative_tolerance_is_sufficiently_tight

 E7:
  IF conservation_property_expected
  THEN compute conservation_balance error

 E8:
  IF regression_test
  THEN use tolerance_aware comparison rather_than exact floating_point equality

 E9:
  IF verification_successful
  THEN explicitly avoid inferring model validity
}

RECURSION {
 ENTRY = ModelVerification

 EXPAND(ModelVerification) -> [
  CodeVerification,
  SolutionVerification,
  CalculationVerification,
  ImplementationVerification,
  NumericalVerification,
  ManufacturedSolution,
  MethodOfManufacturedSolutions,
  AnalyticalSolution,
  BenchmarkProblem,
  ReferenceSolution,
  Residual,
  ConservationCheck,
  ConsistencyCheck,
  ConvergenceStudy,
  GridConvergence,
  MeshConvergence,
  TimeStepConvergence,
  IterativeConvergence,
  DiscretisationError,
  TruncationError,
  RoundoffError,
  IterationError,
  SolverTolerance,
  StabilityCheck,
  RegressionTest,
  Reproducibility,
  ErrorEstimate,
  OrderOfAccuracy,
  VerificationStatus,
  VerificationReport
 ]

 EXPAND(CodeVerification) -> [
  ManufacturedSolution,
  AnalyticalSolution,
  BenchmarkProblem,
  UnitTest,
  IntegrationTest,
  RegressionTest
 ]

 EXPAND(SolutionVerification) -> [
  GridConvergence,
  TimeStepConvergence,
  RichardsonExtrapolation,
  GridConvergenceIndex,
  Residual,
  ErrorEstimate
 ]

 EXPAND(ErrorBudget) -> [
  DiscretisationError,
  TruncationError,
  IterationError,
  RoundoffError,
  SamplingError
 ]

 STOP_CONDITION =
  "Stop when the implementation, reference problem, residual, convergence behaviour, error estimate, conservation status, reproducibility evidence and final verification status are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Mathematical Modelling"

 IMMEDIATE_CONTEXTS = [
  "Computational Model Ontology",
  "Simulation Model Ontology",
  "Mathematical Model Ontology",
  "Numerical Analysis Ontologies"
 ]

 RELATED_ONTOLOGIES = [
  "Computational Model Ontology",
  "Simulation Model Ontology",
  "Mathematical Model Ontology",
  "Mathematical Modelling Ontology",
  "Model Validation Ontology",
  "Applied Mathematics Ontologies",
  "Numerical Analysis Ontologies",
  "Scientific Computing Ontologies",
  "Differential Equations Ontologies",
  "Linear Algebra Ontologies",
  "Scientific Measurement Ontologies",
  "Software Engineering Ontologies"
 ]

 ROUTE_RULES = [
  "Model Verification -> Computational Model Ontology for executable-model semantics",
  "Model Verification -> Simulation Model Ontology for simulation implementation checks",
  "Model Verification -> Mathematical Model Ontology for intended-equation semantics",
  "Model Verification -> Numerical Analysis for convergence, stability and error",
  "Model Verification -> Scientific Computing for reproducibility and solver behaviour",
  "Model Verification -> Differential Equations for governing-equation benchmarks",
  "Model Verification -> Linear Algebra for solver residual and conditioning analysis",
  "Model Verification -> Scientific Measurement for numerical tolerance and units",
  "Model Verification -> Software Engineering for unit, integration and regression testing",
  "Model Verification -> Model Validation Ontology to maintain verification-validation separation"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"

 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible verification methods, benchmarks or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"

 RULES = [
  "Preserve implementation-correctness semantics.",
  "Preserve code-versus-solution verification distinction.",
  "Preserve verification-versus-validation distinction.",
  "Preserve systematic-refinement requirements.",
  "Preserve residual and conservation-check semantics.",
  "Preserve numerical-error decomposition.",
  "Preserve reproducibility evidence.",
  "Preserve machine-readable model-verification semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION =
  "Model verification assesses whether the intended mathematical model has been correctly implemented and solved."

 CODE_VERIFICATION_SUMMARY =
  "Code verification checks whether software correctly implements the governing equations and algorithms."

 SOLUTION_VERIFICATION_SUMMARY =
  "Solution verification estimates numerical error in a particular computed solution."

 MMS_SUMMARY =
  "The method of manufactured solutions tests code using deliberately chosen exact solutions and derived source terms."

 CONVERGENCE_SUMMARY =
  "Convergence studies assess how computed solutions change under systematic numerical refinement."

 RESIDUAL_SUMMARY =
  "Residuals quantify how closely a numerical solution satisfies the implemented equations."

 CONSERVATION_SUMMARY =
  "Conservation checks test whether declared balance laws are preserved to numerical tolerance."

 REPRODUCIBILITY_SUMMARY =
  "Verification evidence should preserve code version, solver settings, tolerances, inputs and numerical precision."

 DISTINCTION_SUMMARY =
  "Successful verification supports implementation correctness but does not establish model validity."
}

FLOW {
 INPUT
 -> detect_model_verification_context
 -> identify mathematical_specification_implementation_numerical_method_solver_discretisation_and_tolerances
 -> classify code_verification_solution_verification_residual_convergence_conservation_benchmark_or_regression goal
 -> select analytical_reference_manufactured_solution_benchmark_or_refinement method
 -> execute verification tests
 -> compute residuals_errors_convergence_rates_and_conservation balances
 -> assess asymptotic_regime_iteration_error_roundoff_and_tolerance adequacy
 -> preserve reproducibility_and_provenance metadata
 -> assign verification_status_with_limitations
 -> route to computational_model simulation_model mathematical_model numerical_analysis scientific_computing differential_equations linear_algebra measurement software_engineering_or_model_validation ontology
 -> recursively_expand_required_dependencies
 -> verify_result
 -> assign_confidence
 -> produce_semantic_output
 -> END
}

SEMANTIC_SUMMARY {
 "The Model Verification Ontology defines the assessment of whether mathematical and computational models are implemented and solved correctly. It supports code and solution verification, manufactured solutions, benchmarks, residuals, conservation checks, mesh and time-step convergence, observed order of accuracy, numerical error decomposition, solver tolerances, regression testing, reproducibility and explicit separation from model validation."
}

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

}

END_FLOW