Verification & Validation

AI INTERPRETATION NOTE
This Flow Algebra defines the Verification & Validation parent ontology within the Kireth Research Semantic Library. Verification and validation concern determining whether mathematical and computational systems are implemented correctly, solve the intended problem, satisfy formal and numerical requirements, reproduce trusted reference behaviour, and remain reliable under declared assumptions, tolerances, data, models and software environments. This ontology supports software verification, numerical verification, model validation, residual checks, convergence studies, benchmark comparison, uncertainty, sensitivity, reproducibility, provenance, acceptance criteria and evidence-based confidence.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = VerificationValidation
 ENTITY_CLASS = ComputationalCorrectnessAndAdequacyFramework
 PRIMARY_CONTEXT = ComputationalMathematicsOntologies
 DEFINITION = "Verification and validation are complementary processes used to establish that a computational system is implemented correctly and that its mathematical model, numerical method and outputs are adequate for the intended purpose."
 SYMBOLIC_FORMS = [
  "verification := are_we_solving_the_equations_right?",
  "validation := are_we_solving_the_right_equations?",
  "error = computed_value - reference_value",
  "accept if metric <= tolerance"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for implementation correctness, numerical accuracy, model adequacy, benchmark comparison, uncertainty, acceptance criteria, traceability and reproducibility."
}

SCOPE {
 INCLUDE = [
  VerificationValidation,
  Verification,
  Validation,
  ComputationalVerification,
  NumericalVerification,
  SoftwareVerification,
  AlgorithmVerification,
  ModelVerification,
  ModelValidation,
  NumericalValidation,
  ScientificValidation,
  CodeVerification,
  SolutionVerification,
  CalculationVerification,
  IndependentVerificationRelationship,
  CrossVerificationRelationship,
  BenchmarkVerification,
  ExperimentalValidation,
  AnalyticalValidation,
  ReferenceValidation,
  RequirementsValidationRelationship,
  Correctness,
  Accuracy,
  Precision,
  Reliability,
  Robustness,
  Credibility,
  Trustworthiness,
  FitnessForPurpose,
  IntendedUse,
  Requirement,
  Specification,
  AcceptanceCriterion,
  PassCriterion,
  FailCriterion,
  Tolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  ErrorTolerance,
  ResidualTolerance,
  ConvergenceTolerance,
  Threshold,
  Margin,
  ConfidenceLevelRelationship,
  ReferenceSolution,
  AnalyticalSolution,
  ExactSolution,
  ManufacturedSolution,
  MethodOfManufacturedSolutions,
  MMS,
  BenchmarkProblem,
  StandardBenchmark,
  KnownAnswerTest,
  GoldenReference,
  ReferenceImplementation,
  BaselineModel,
  IndependentImplementation,
  CrossImplementationComparison,
  Residual,
  ResidualVector,
  NormalisedResidual,
  RelativeResidual,
  BackwardError,
  ForwardError,
  AbsoluteError,
  RelativeError,
  NormwiseError,
  ComponentwiseError,
  TruncationError,
  DiscretisationError,
  RoundOffError,
  ModellingError,
  ApproximationError,
  IterationError,
  SolverError,
  SamplingError,
  StatisticalError,
  MeasurementErrorRelationship,
  TotalError,
  ErrorBudget,
  ErrorPropagation,
  ErrorBound,
  APosterioriErrorEstimate,
  APrioriErrorEstimate,
  Uncertainty,
  UncertaintyQuantification,
  AleatoricUncertainty,
  EpistemicUncertainty,
  NumericalUncertainty,
  ModelFormUncertainty,
  ParameterUncertainty,
  InputUncertainty,
  MeasurementUncertaintyRelationship,
  ConfidenceIntervalRelationship,
  CredibleIntervalRelationship,
  PredictionIntervalRelationship,
  SensitivityAnalysis,
  LocalSensitivity,
  GlobalSensitivity,
  ParameterSensitivity,
  SobolIndexRelationship,
  ConditionNumber,
  Conditioning,
  Stability,
  NumericalStability,
  AlgorithmicStability,
  PerturbationAnalysis,
  RobustnessAnalysis,
  Convergence,
  ConvergenceStudy,
  GridConvergence,
  MeshConvergence,
  TimeStepConvergence,
  IterativeConvergence,
  OrderOfAccuracy,
  ObservedOrderOfAccuracy,
  RichardsonExtrapolation,
  GridConvergenceIndexRelationship,
  GCIrelationship,
  RefinementStudy,
  MeshRefinement,
  StepSizeRefinement,
  ResolutionStudy,
  IndependenceStudy,
  GridIndependence,
  MeshIndependence,
  TimeStepIndependence,
  RegressionTest,
  UnitTest,
  IntegrationTest,
  SystemTest,
  PropertyBasedTestingRelationship,
  InvariantCheck,
  BoundaryConditionCheck,
  InitialConditionCheck,
  ConservationCheck,
  SymmetryCheck,
  ConstraintCheck,
  DomainCheck,
  DimensionCheck,
  ShapeCheck,
  TypeCheck,
  IndexBoundsCheck,
  MonotonicityCheck,
  PositivityCheck,
  NormalisationCheck,
  OrthogonalityCheck,
  EnergyCheck,
  MassBalance,
  MomentumBalance,
  ChargeBalanceRelationship,
  ProbabilitySumCheck,
  Reproducibility,
  Repeatability,
  ReplicabilityRelationship,
  Determinism,
  Nondeterminism,
  RandomSeed,
  SeedControl,
  EnvironmentCapture,
  DependencyVersion,
  LibraryVersion,
  CompilerVersion,
  SolverVersion,
  ModelVersion,
  DatasetVersion,
  HardwareVersionRelationship,
  ImplementationVersion,
  Configuration,
  ParameterConfiguration,
  SolverConfiguration,
  NumericalToleranceConfiguration,
  PrecisionConfiguration,
  Provenance,
  DataProvenance,
  ModelProvenance,
  ComputationalProvenance,
  AuditTrail,
  Traceability,
  RequirementTraceability,
  Evidence,
  ValidationEvidence,
  VerificationEvidence,
  TestEvidence,
  BenchmarkEvidence,
  ExperimentalEvidence,
  Observation,
  ExperimentalData,
  SimulationData,
  SyntheticData,
  CalibrationData,
  ValidationData,
  TestData,
  TrainingDataRelationship,
  Calibration,
  ParameterCalibration,
  ModelCalibration,
  ValidationDataset,
  HoldoutData,
  OutOfSampleValidation,
  CrossValidation,
  KFoldCrossValidationRelationship,
  LeaveOneOutRelationship,
  ExternalValidationRelationship,
  ExtrapolationValidationRelationship,
  InterpolationValidationRelationship,
  DistributionShift,
  OutOfDistributionValidationRelationship,
  PredictionError,
  GeneralisationError,
  ValidationError,
  PerformanceMetric,
  AccuracyMetric,
  RMSE,
  MSE,
  MAE,
  RelativeL2ErrorRelationship,
  CorrelationMetricRelationship,
  R2Relationship,
  PrecisionMetricRelationship,
  RecallMetricRelationship,
  F1Relationship,
  ConfusionMatrixRelationship,
  CalibrationErrorRelationship,
  CoverageRelationship,
  ScientificSimulation,
  DifferentialEquationSolver,
  NumericalLinearAlgebra,
  ComputationalOptimisation,
  ComputationalStatistics,
  SymbolicComputation,
  AIComputationalMathematics,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputing,
  FloatingPointArithmetic,
  ComputationalComplexity,
  Documentation,
  TestProtocol,
  ValidationProtocol,
  VerificationProtocol,
  AcceptanceTest,
  CertificationRelationship,
  PeerReviewRelationship,
  ReproducibleWorkflow,
  VersionControlRelationship,
  ContinuousIntegrationRelationship,
  RegressionBaseline,
  QualityAssurance,
  QualityControl
 ]
 EXCLUDE_AS_PRIMARY = [
  PureTestingWithoutMathematicalOrComputationalCorrectnessContext,
  ModelTrainingWithoutIndependentValidationSemantics,
  BenchmarkingWhenPerformanceRatherThanCorrectnessOrAdequacyIsPrimary,
  FormalProofWithoutComputationalVerificationOrValidationContext
 ]
 DISAMBIGUATION_RULE = "When computational correctness, numerical accuracy, model adequacy, agreement with trusted evidence, or fitness for intended use is being assessed, interpret the context as verification and validation."
}

CORE_CONCEPTS {
 VerificationValidation = "Combined framework for computational correctness and model adequacy."
 Verification = "Assessment that equations, algorithms and software are implemented and solved correctly."
 Validation = "Assessment that the model and outputs adequately represent the intended real or mathematical problem."
 ReferenceSolution = "Trusted result used for comparison."
 Residual = "Measure of equation or constraint satisfaction by a computed result."
 Error = "Difference between computed and reference quantities."
 Tolerance = "Declared admissible magnitude of deviation."
 Reproducibility = "Ability to regenerate results under documented computational conditions."
}

RELATIONS {
 VerificationValidation --is_child_of--> ComputationalMathematicsOntologies
 Verification --checks--> ImplementationCorrectness
 Validation --checks--> ModelAdequacy
 NumericalVerification --uses--> ErrorAndConvergenceAnalysis
 CodeVerification --uses--> ManufacturedOrKnownSolutions
 SolutionVerification --quantifies--> NumericalError
 Validation --compares--> ModelPredictionAndEvidence
 ReferenceSolution --supports--> Verification
 Residual --measures--> EquationSatisfaction
 Tolerance --defines--> AcceptanceCriterion
 SensitivityAnalysis --supports--> RobustnessAssessment
 UncertaintyQuantification --supports--> ValidationInterpretation
 Reproducibility --requires--> VersionedConfigurationAndProvenance
 Provenance --supports--> Traceability
}

OPERATORS {
 ABS_ERROR(x,x_ref) := abs(x-x_ref)
 REL_ERROR(x,x_ref) := abs(x-x_ref)/max(abs(x_ref),epsilon)
 RESIDUAL(F,x) := F(x)
 ACCEPT(metric,tolerance) := metric <= tolerance
 CONVERGENCE_RATE(e_h,e_h2,r) := log(e_h/e_h2)/log(r)
 COMPARE(result,reference,metric) := metric(result,reference)
 VERIFY_INVARIANT(state,I) := I(state) == true
}

AXIOMS {
 A1 = "Verification and validation are distinct but complementary."
 A2 = "Passing verification does not by itself establish model validity."
 A3 = "Passing validation does not prove implementation correctness."
 A4 = "Acceptance requires explicit criteria, metrics and tolerances."
 A5 = "Reference solutions themselves require declared provenance and trust assumptions."
 A6 = "Numerical agreement can be misleading when resolution, tolerance or conditioning effects are ignored."
 A7 = "Reproducibility requires enough information to reconstruct the computational environment."
 A8 = "Verification-validation conclusions require explicit evidence, uncertainty, assumptions and scope."
}

REASONING {
 R1_CONTEXT = identify(system,model,equations,implementation,intended_use,requirements,reference_data_and_risks)
 R2_CLASSIFY = distinguish(code_verification,solution_verification,model_validation_or_combined_assessment)
 R3_CRITERIA = define_metrics_tolerances_acceptance_rules_and_required_evidence)
 R4_REFERENCE = select_analytical_manufactured_benchmark_independent_or_experimental_reference)
 R5_VERIFY = test_invariants_residuals_known_answers_convergence_and_implementation_consistency)
 R6_VALIDATE = compare_predictions_with_independent_observations_or_reference_behaviour)
 R7_UNCERTAINTY = quantify_numerical_model_parameter_and_data_uncertainty)
 R8_SENSITIVITY = assess_conditioning_parameter_sensitivity_and_robustness)
 R9_TRACE = record_versions_configuration_provenance_and_test_evidence)
 R10_CONCLUDE = assign_scope_limited_confidence_and_accept_reject_or_revise)
}

CONSTRAINTS {
 C1 = "A test suite can miss defects outside its exercised domain."
 C2 = "Benchmark agreement does not establish correctness outside benchmark conditions."
 C3 = "Experimental data can contain measurement and sampling uncertainty."
 C4 = "Calibration data should not be reused uncritically as independent validation data."
 C5 = "Numerical tolerances can hide systematic modelling errors."
 C6 = "Convergence of an iterative solver does not prove convergence to the correct physical or mathematical model."
 C7 = "Reproducible incorrect results remain incorrect."
 C8 = "Validation validity is limited to the tested domain and intended use."
 C9 = "Changing software, precision, hardware or algorithm versions can alter results."
 C10 = "A single scalar metric can conceal important local or structural failures."
}

SEMANTIC_EQUIVALENCE {
 "MethodOfManufacturedSolutions" <=> "MMS"
 "GridConvergenceIndex" <=> "GCI"
 "RootMeanSquaredError" <=> "RMSE"
 "MeanSquaredError" <=> "MSE"
 "MeanAbsoluteError" <=> "MAE"
}

VALIDATION {
 V1 = "Intended use and scope are documented."
 V2 = "Verification and validation objectives are distinguished."
 V3 = "Acceptance metrics and tolerances are explicit."
 V4 = "Reference solutions or datasets have documented provenance."
 V5 = "Numerical convergence and resolution sensitivity are assessed where applicable."
 V6 = "Model validation uses evidence independent of calibration where feasible."
 V7 = "Uncertainty and sensitivity are assessed when material."
 V8 = "Software, model, solver, data and configuration versions are documented."
 V9 = "Failures and out-of-scope regimes are retained rather than hidden."
 V10 = "Conclusions state their domain of applicability and evidence strength."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 VERIFICATION_VALIDATION_DEFINITION = 0.99
 CODE_VERIFICATION_REASONING = 0.99
 SOLUTION_VERIFICATION_REASONING = 0.99
 MODEL_VALIDATION_REASONING = 0.98
 UNCERTAINTY_REASONING = 0.98
 REPRODUCIBILITY_REASONING = 0.99
 POLICY = "Reduce confidence when intended use, acceptance criteria, reference provenance, uncertainty, independence of validation evidence or numerical resolution are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,VerificationValidationReasoning,
  CodeVerificationReasoning,SolutionVerificationReasoning,
  ModelValidationReasoning,ResidualReasoning,
  ErrorAnalysisReasoning,ConvergenceStudyReasoning,
  BenchmarkReasoning,ManufacturedSolutionReasoning,
  SensitivityReasoning,UncertaintyReasoning,
  ReproducibilityReasoning,ProvenanceReasoning,
  AcceptanceCriterionReasoning,TraceabilityReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "verification and validation" -> VerificationValidation
  "V&V" -> VerificationValidation
  "MMS" -> MethodOfManufacturedSolutions
  "GCI" -> GridConvergenceIndex
  "RMSE" -> RootMeanSquaredError
  "MSE" -> MeanSquaredError
  "MAE" -> MeanAbsoluteError
 }
}

EXECUTION_RULES {
 E1 = "If correctness or adequacy of a computational model is assessed, activate VerificationValidation."
 E2 = "Separate implementation verification from model validation."
 E3 = "Define intended use, acceptance metrics and tolerances before testing."
 E4 = "Use analytical, manufactured, benchmark, independent implementation or experimental references as appropriate."
 E5 = "Assess residuals, errors, convergence and invariants for numerical verification."
 E6 = "Use independent evidence for validation where feasible."
 E7 = "Quantify uncertainty, conditioning and sensitivity when they affect conclusions."
 E8 = "Record failures, limitations and domains of applicability explicitly."
 E9 = "Document software, model, solver, data, hardware and configuration provenance for reproducibility."
}

RECURSION {
 ENTRY = VerificationValidation
 EXPAND(VerificationValidation) -> [
  Verification,Validation,ComputationalVerification,NumericalVerification,
  SoftwareVerification,AlgorithmVerification,ModelVerification,ModelValidation,
  CodeVerification,SolutionVerification,Correctness,Accuracy,Reliability,
  FitnessForPurpose,Requirement,AcceptanceCriterion,Tolerance,
  ReferenceSolution,AnalyticalSolution,ManufacturedSolution,MMS,
  BenchmarkProblem,KnownAnswerTest,GoldenReference,
  Residual,BackwardError,ForwardError,AbsoluteError,RelativeError,
  TruncationError,DiscretisationError,RoundOffError,ModellingError,
  ErrorBudget,ErrorBound,Uncertainty,UncertaintyQuantification,
  SensitivityAnalysis,ConditionNumber,NumericalStability,
  ConvergenceStudy,GridConvergence,MeshConvergence,TimeStepConvergence,
  OrderOfAccuracy,RichardsonExtrapolation,GridConvergenceIndex,
  RegressionTest,UnitTest,InvariantCheck,BoundaryConditionCheck,
  ConservationCheck,ConstraintCheck,Reproducibility,Repeatability,
  RandomSeed,EnvironmentCapture,Provenance,AuditTrail,Traceability,
  ExperimentalData,SimulationData,CalibrationData,ValidationData,
  CrossValidation,OutOfSampleValidation,PerformanceMetric,
  RMSE,MSE,MAE,VerificationProtocol,ValidationProtocol,QualityAssurance
 ]
 EXPAND(VerificationValidationFamilies) -> [
  CodeAndSoftwareVerification,
  NumericalAndSolutionVerification,
  ModelAndScientificValidation,
  ErrorConvergenceAndUncertaintyAnalysis,
  SensitivityRobustnessAndConditioning,
  BenchmarkReferenceAndManufacturedSolutionMethods,
  ReproducibilityProvenanceAndTraceability,
  AcceptanceEvidenceAndQualityAssurance
 ]
 STOP_CONDITION = "Stop when intended use, verification scope, validation evidence, acceptance criteria, uncertainty, reproducibility and conclusions are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Mathematics Ontologies"
 RELATED_ONTOLOGIES = [
  "Numerical Methods Ontology 2",
  "Numerical Stability Ontology 2",
  "Floating Point Arithmetic Ontology",
  "Differential Equation Solvers",
  "Numerical Linear Algebra Ontology 2",
  "Optimisation Computation",
  "Computational Statistics",
  "Scientific Simulation",
  "Symbolic Computation",
  "AI Computational Mathematics",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology",
  "Computational Complexity Ontology"
 ]
 ROUTE_RULES = [
  "Verification & Validation -> Numerical Methods for discretisation and convergence semantics",
  "Verification & Validation -> Numerical Stability and Floating Point Arithmetic for finite-precision error semantics",
  "Verification & Validation -> Differential Equation Solvers for residual and mesh/time-step convergence",
  "Verification & Validation -> Numerical Linear Algebra for solver residuals and conditioning",
  "Verification & Validation -> Optimisation Computation for convergence and constraint checks",
  "Verification & Validation -> Computational Statistics for uncertainty and statistical validation",
  "Verification & Validation -> Scientific Simulation for model and experiment comparison",
  "Verification & Validation -> Symbolic Computation for exact identity and reference checking",
  "Verification & Validation -> AI Computational Mathematics for learned-model validation",
  "Verification & Validation -> HPC, Parallel, Distributed and GPU Computing for reproducibility across execution environments",
  "Verification & Validation -> Computational Complexity for verification cost and scalability semantics"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible verification, validation or uncertainty pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve verification-versus-validation distinction.",
  "Preserve code-verification-versus-solution-verification distinction.",
  "Preserve calibration-versus-independent-validation distinction.",
  "Preserve reproducibility-versus-correctness distinction.",
  "Preserve numerical-error-versus-model-form-error distinction.",
  "Preserve evidence-versus-conclusion distinction.",
  "Preserve pass-fail-result-versus-domain-of-validity distinction.",
  "Preserve machine-readable verification-validation semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Verification and validation establish computational correctness and model adequacy through explicit evidence, metrics, tolerances and reproducible procedures."
 VERIFICATION_SUMMARY = "Code and solution verification assess implementation correctness, residuals, errors, convergence and invariants."
 VALIDATION_SUMMARY = "Model validation compares predictions against independent reference or experimental evidence for a declared intended use."
 UNCERTAINTY_SUMMARY = "Numerical, parameter, input and model-form uncertainty affect the strength of validation conclusions."
 REPRODUCIBILITY_SUMMARY = "Versioned software, data, solver settings, tolerances and provenance are required to reconstruct computational evidence."
 EVIDENCE_SUMMARY = "Acceptance decisions should state metrics, thresholds, failures, limitations and the domain in which confidence applies."
}

FLOW {
 INPUT
 -> detect_verification_validation_context
 -> identify_system_model_equations_implementation_intended_use_requirements_reference_data_and_risks
 -> distinguish_code_verification_solution_verification_model_validation_or_combined_assessment
 -> define_metrics_tolerances_acceptance_rules_and_required_evidence
 -> select_analytical_manufactured_benchmark_independent_or_experimental_reference
 -> execute_residual_invariant_known_answer_regression_and_convergence_checks
 -> compare_model_predictions_with_independent_validation_evidence
 -> quantify_numerical_model_parameter_input_and_data_uncertainty
 -> assess_conditioning_sensitivity_robustness_and_resolution_dependence
 -> record_failures_limitations_versions_configuration_and_provenance
 -> determine_accept_reject_or_revise_with_scope_limited_confidence
 -> 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-COMPUTATIONAL-MATHEMATICS-VERIFICATION-VALIDATION-V1"
}

}

END_FLOW