Reproducibility Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Reproducibility Ontology within the Kireth Research Semantic Library. Reproducibility concerns the ability to regenerate computational results from documented data, code, models, parameters, software, hardware assumptions, random seeds, numerical precision and execution environments. This ontology supports repeatability, replicability relationships, deterministic and stochastic workflows, environment capture, versioning, dependency locking, containers, provenance, audit trails, workflow specifications, seed control, dataset and model lineage, numerical tolerance, cross-platform variation, result comparison, verification, validation and evidence-based reproducibility claims.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = Reproducibility
 ENTITY_CLASS = ComputationalResultRegenerationFramework
 PRIMARY_CONTEXT = VerificationValidation
 DEFINITION = "Reproducibility is the ability to regenerate computational results from sufficiently documented and versioned computational artefacts, configurations, data, software and execution conditions."
 SYMBOLIC_FORMS = [
  "result = f(code,data,config,environment,seed)",
  "reproduce(result_ref) -> result_new ≈ result_ref",
  "provenance := lineage(code,data,model,environment)",
  "accept_reproduction if difference <= tolerance"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for result regeneration, environment capture, versioning, seed control, provenance, workflow specification, tolerance-aware comparison and reproducibility evidence."
}

SCOPE {
 INCLUDE = [
  Reproducibility,
  ComputationalReproducibility,
  NumericalReproducibility,
  ScientificReproducibility,
  ExperimentalReproducibilityRelationship,
  Repeatability,
  ReplicabilityRelationship,
  Regeneration,
  ResultRegeneration,
  ReproductionRun,
  ReproducibleWorkflow,
  Workflow,
  ComputationalWorkflow,
  Pipeline,
  ExecutionPipeline,
  WorkflowStep,
  DependencyGraphRelationship,
  Input,
  Output,
  IntermediateResult,
  Artifact,
  ComputationalArtifact,
  DataArtifact,
  ModelArtifact,
  SoftwareArtifact,
  EnvironmentArtifactRelationship,
  Code,
  SourceCode,
  Script,
  NotebookRelationship,
  Executable,
  Binary,
  BuildArtifact,
  RepositoryRelationship,
  Commit,
  Revision,
  Tag,
  Release,
  Version,
  SemanticVersionRelationship,
  VersionControl,
  GitRelationship,
  BranchRelationship,
  Data,
  Dataset,
  InputData,
  RawData,
  ProcessedData,
  DerivedData,
  TrainingDataRelationship,
  ValidationData,
  TestData,
  DatasetVersion,
  DatasetHash,
  Checksum,
  FileHash,
  ContentHash,
  Model,
  ComputationalModel,
  TrainedModelRelationship,
  ModelVersion,
  ModelCheckpointRelationship,
  Parameter,
  ParameterSet,
  HyperparameterRelationship,
  Configuration,
  ConfigurationFile,
  ParameterConfiguration,
  SolverConfiguration,
  PrecisionConfiguration,
  ToleranceConfiguration,
  HardwareConfiguration,
  EnvironmentConfiguration,
  CommandLineArgumentRelationship,
  EnvironmentVariable,
  Randomness,
  RandomSeed,
  SeedControl,
  SeedSequenceRelationship,
  PseudorandomNumberGenerator,
  PRNG,
  RandomNumberGenerator,
  RNGStateRelationship,
  DeterministicExecution,
  Determinism,
  Nondeterminism,
  StochasticExecution,
  StochasticWorkflow,
  RepeatedRun,
  Replicate,
  Trial,
  RunIdentifier,
  ExecutionIdentifier,
  TimestampRelationship,
  SoftwareEnvironment,
  RuntimeEnvironment,
  OperatingSystem,
  KernelVersionRelationship,
  Compiler,
  CompilerVersion,
  InterpreterRelationship,
  Runtime,
  RuntimeVersion,
  Library,
  LibraryVersion,
  Dependency,
  DependencyVersion,
  DependencyGraph,
  Package,
  PackageVersion,
  PackageManagerRelationship,
  LockFile,
  DependencyLock,
  EnvironmentLock,
  RequirementsFileRelationship,
  VirtualEnvironment,
  Container,
  ContainerImage,
  ContainerDigest,
  ImageTag,
  DockerRelationship,
  SingularityRelationship,
  ApptainerRelationship,
  EnvironmentCapture,
  EnvironmentSnapshot,
  BuildRecipe,
  ContainerRecipe,
  InfrastructureAsCodeRelationship,
  Hardware,
  CPU,
  GPU,
  Accelerator,
  Device,
  CoreCount,
  ThreadCount,
  Memory,
  Architecture,
  InstructionSetRelationship,
  Driver,
  DriverVersion,
  CUDArelationship,
  CUDAVersionRelationship,
  BLASLibraryRelationship,
  MathLibrary,
  HardwareVersion,
  DevicePlacementRelationship,
  Precision,
  FloatingPointPrecision,
  SinglePrecision,
  DoublePrecision,
  MixedPrecision,
  MachinePrecision,
  FloatingPointArithmetic,
  NumericalTolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  ComparisonTolerance,
  ResultComparison,
  ExactComparison,
  ApproximateComparison,
  ToleranceAwareComparison,
  DistributionalComparison,
  StructuralComparison,
  SemanticComparisonRelationship,
  HashComparison,
  ChecksumVerification,
  Provenance,
  ComputationalProvenance,
  DataProvenance,
  ModelProvenance,
  SoftwareProvenance,
  EnvironmentProvenance,
  ResultProvenance,
  Lineage,
  DataLineage,
  ModelLineage,
  WorkflowLineage,
  TransformationHistory,
  AuditTrail,
  Traceability,
  Metadata,
  MetadataRecord,
  Manifest,
  RunManifest,
  ProvenanceRecord,
  EvidenceRecord,
  ReproductionReport,
  ReproducibilityReport,
  Documentation,
  READMErelationship,
  MethodsRecord,
  ExecutionRecord,
  Log,
  RunLog,
  ErrorLogRelationship,
  TestLogRelationship,
  ContinuousIntegrationRelationship,
  AutomatedWorkflowRelationship,
  ScheduledWorkflowRelationship,
  WorkflowOrchestrationRelationship,
  Caching,
  Cache,
  CacheKey,
  CacheInvalidationRelationship,
  MemoisationRelationship,
  DataVersioningRelationship,
  ModelRegistryRelationship,
  ArtifactRegistryRelationship,
  ObjectStorageRelationship,
  BackupRelationship,
  ArchiveRelationship,
  PersistentIdentifierRelationship,
  DOIrelationship,
  ReproducibilityPackageRelationship,
  ResearchCompendiumRelationship,
  ReferenceResult,
  BaselineResult,
  GoldenReference,
  KnownAnswerTest,
  RegressionTesting,
  Benchmark,
  NumericalVerification,
  ComputationalValidation,
  ErrorAnalysis,
  VerificationValidation,
  NumericalStability,
  ComputationalStatistics,
  ScientificSimulation,
  AIComputationalMathematics,
  SymbolicComputation,
  NumericalLinearAlgebra,
  DifferentialEquationSolver,
  ComputationalOptimisation,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputing,
  ParallelNondeterminismRelationship,
  ReductionOrderRelationship,
  RaceConditionRelationship,
  ThreadSchedulingRelationship,
  DistributedOrderingRelationship,
  CollectiveCommunicationRelationship,
  ReproducibilityLevel,
  BitwiseReproducibility,
  NumericalReproducibility,
  StatisticalReproducibility,
  SemanticReproducibility,
  FunctionalReproducibilityRelationship,
  CrossPlatformReproducibility,
  CrossHardwareReproducibility,
  CrossCompilerReproducibility,
  CrossLibraryReproducibility,
  ReproducibilityCriterion,
  AcceptanceCriterion,
  PassCriterion,
  FailCriterion,
  EvidenceStrength,
  Confidence,
  Limitation,
  DomainOfReproducibilityRelationship,
  ReproducibilityFailure,
  MissingDependency,
  VersionMismatch,
  SeedMismatch,
  DataMismatch,
  EnvironmentMismatch,
  HardwareMismatch,
  PrecisionMismatch,
  ToleranceMismatch,
  NondeterministicFailure,
  StaleCacheRelationship,
  HiddenStateRelationship,
  ExternalServiceDependencyRelationship,
  NetworkDependencyRelationship,
  TimeDependentDependencyRelationship
 ]
 EXCLUDE_AS_PRIMARY = [
  CorrectnessAssessmentWithoutResultRegenerationContext,
  ValidationWithoutExecutionReconstruction,
  ReplicationOfPhysicalExperimentWithoutComputationalWorkflowContext,
  BackupOrArchivingWithoutReproducibilityIntent
 ]
 DISAMBIGUATION_RULE = "When the ability to regenerate computational results from documented and versioned artefacts, settings and environments is being assessed, interpret the context as reproducibility."
}

CORE_CONCEPTS {
 Reproducibility = "Ability to regenerate computational results from documented computational conditions."
 Repeatability = "Ability to obtain consistent results under the same team, setup and conditions."
 Replicability = "Related concept involving independent recreation or execution under separately established conditions."
 Provenance = "Traceable lineage of data, code, models, configurations and results."
 EnvironmentCapture = "Recording of software, dependency, runtime and hardware conditions."
 SeedControl = "Explicit management of pseudorandom initial states."
 ToleranceAwareComparison = "Comparison that accepts declared numerical deviations."
 ReproducibleWorkflow = "Workflow whose computational steps and dependencies are explicitly specified and rerunnable."
}

RELATIONS {
 Reproducibility --is_child_of--> VerificationValidation
 Reproducibility --requires--> VersionedArtifacts
 Reproducibility --requires--> EnvironmentCapture
 Reproducibility --requires--> Provenance
 ReproducibleWorkflow --contains--> WorkflowSteps
 WorkflowStep --consumes--> Inputs
 WorkflowStep --produces--> Outputs
 RandomSeed --controls--> PseudorandomSequence
 LockFile --constrains--> DependencyVersions
 ContainerImage --encapsulates--> RuntimeEnvironment
 Provenance --links--> InputsCodeConfigurationAndResults
 ResultComparison --checks--> ReproductionAgreement
 RegressionTesting --uses--> ReproducibleBaselines
 Benchmark --requires--> ReproducibleProtocol
}

OPERATORS {
 REPRODUCE(workflow,inputs,config,environment,seed) := execute(workflow,inputs,config,environment,seed)
 HASH(artifact) := content_hash(artifact)
 MATCH_HASH(a,b) := HASH(a) == HASH(b)
 NUMERIC_MATCH(x,y,atol,rtol) := abs(x-y) <= atol + rtol*abs(y)
 CAPTURE_ENV() := versions(OS,compiler,runtime,libraries,hardware)
 TRACE(result) := lineage_of(result)
 COMPARE_RUNS(run_a,run_b) := declared_result_comparison(run_a,run_b)
}

AXIOMS {
 A1 = "Reproducibility requires enough information to reconstruct the computational process."
 A2 = "Reproducible results can still be incorrect."
 A3 = "Bitwise identity is stronger than numerical or statistical reproducibility."
 A4 = "Randomness must be controlled or statistically characterised."
 A5 = "Software and dependency versions can materially affect results."
 A6 = "Parallel and distributed execution can introduce nondeterministic reduction order."
 A7 = "Reproducibility claims require a declared comparison criterion."
 A8 = "Computational reproducibility requires explicit artefact, configuration, environment, provenance and evidence semantics."
}

REASONING {
 R1_CONTEXT = identify(result,workflow,inputs,data,model,configuration,software,hardware,randomness_and_claimed_reproducibility_level)
 R2_ARTIFACTS = enumerate_required_code_data_model_dependency_and_configuration_artifacts)
 R3_VERSIONS = resolve_and_lock_relevant_versions)
 R4_ENVIRONMENT = capture_or_reconstruct_runtime_hardware_and_dependency_environment)
 R5_RANDOMNESS = capture_seeds_PRNG_state_and_stochastic_procedures)
 R6_EXECUTE = rerun_workflow_using_declared_conditions)
 R7_COMPARE = apply_bitwise_numerical_statistical_structural_or_semantic_comparison)
 R8_DIAGNOSE = if_mismatch inspect_artifact_version_seed_precision_ordering_cache_and_environment_differences)
 R9_RECORD = preserve_run_manifest_logs_hashes_results_and_provenance)
 R10_CONCLUDE = assign_reproducibility_status_scope_limitations_and_confidence)
}

CONSTRAINTS {
 C1 = "A fixed random seed does not guarantee bitwise reproducibility across all hardware or libraries."
 C2 = "Parallel reductions can differ because floating-point addition is not associative."
 C3 = "Mutable external data can invalidate historical workflows."
 C4 = "Unpinned dependencies can change behaviour over time."
 C5 = "Containers improve environment capture but do not automatically capture hardware semantics or external services."
 C6 = "Cached results can conceal nonreproducible underlying computation."
 C7 = "Bitwise comparison can be too strict for numerically equivalent floating-point results."
 C8 = "Statistical reproducibility requires enough repeated runs to characterise variability."
 C9 = "Cross-platform reproducibility can require looser but explicitly justified criteria."
 C10 = "Missing provenance weakens any reproducibility claim."
}

SEMANTIC_EQUIVALENCE {
 "PseudorandomNumberGenerator" <=> "PRNG"
 "RandomNumberGenerator" <=> "RNG"
 "ContinuousIntegration" <=> "CI"
 "BitwiseReproducibility" <=> "ExactBinaryReproducibility"
}

VALIDATION {
 V1 = "Code or executable version is documented."
 V2 = "Input data and dataset versions are documented."
 V3 = "Model, parameter and configuration versions are documented."
 V4 = "Dependency versions and runtime environment are documented."
 V5 = "Random seeds or stochastic procedures are documented."
 V6 = "Numerical precision and result-comparison tolerances are documented."
 V7 = "Hardware-sensitive settings are documented when material."
 V8 = "Run manifests, logs and provenance records are retained."
 V9 = "Reproduction failures record mismatch sources where identified."
 V10 = "Reproducibility conclusions state the tested environment and comparison level."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 REPRODUCIBILITY_DEFINITION = 0.99
 ENVIRONMENT_CAPTURE_REASONING = 0.99
 PROVENANCE_REASONING = 0.99
 SEED_CONTROL_REASONING = 0.99
 CROSS_PLATFORM_REASONING = 0.97
 PARALLEL_REPRODUCIBILITY_REASONING = 0.97
 POLICY = "Reduce confidence when dependencies, data versions, random-state handling, precision, hardware assumptions, external services or provenance are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,ReproducibilityReasoning,
  RepeatabilityReasoning,ReplicabilityReasoning,
  EnvironmentCaptureReasoning,DependencyLockingReasoning,
  SeedControlReasoning,ProvenanceReasoning,
  WorkflowReconstructionReasoning,ArtifactVersioningReasoning,
  ContainerReasoning,HashReasoning,
  BitwiseReproducibilityReasoning,NumericalReproducibilityReasoning,
  StatisticalReproducibilityReasoning,
  CrossPlatformReasoning,ParallelNondeterminismReasoning,
  ReproducibilityFailureReasoning,VerificationReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "reproducibility" -> Reproducibility
  "repeatability" -> Repeatability
  "replicability" -> Replicability
  "PRNG" -> PseudorandomNumberGenerator
  "RNG" -> RandomNumberGenerator
  "CI" -> ContinuousIntegration
 }
}

EXECUTION_RULES {
 E1 = "If computational result regeneration is being assessed, activate ReproducibilityOntology."
 E2 = "Enumerate all required code, data, model, configuration and environment artefacts."
 E3 = "Pin or record dependency and software versions."
 E4 = "Capture random seeds and stochastic state where applicable."
 E5 = "Choose bitwise, numerical, statistical, structural or semantic comparison explicitly."
 E6 = "Treat hardware, compiler, library and parallel-order differences as potential reproducibility factors."
 E7 = "Preserve logs, hashes, run manifests and provenance."
 E8 = "Diagnose mismatches before weakening acceptance criteria."
 E9 = "State the tested reproducibility level, scope and limitations."
}

RECURSION {
 ENTRY = Reproducibility
 EXPAND(Reproducibility) -> [
  ComputationalReproducibility,NumericalReproducibility,
  Repeatability,ReplicabilityRelationship,ResultRegeneration,
  ReproducibleWorkflow,ComputationalWorkflow,WorkflowStep,
  Artifact,Code,SourceCode,Executable,RepositoryRelationship,
  Commit,VersionControl,Dataset,DatasetVersion,DatasetHash,
  Model,ModelVersion,ParameterSet,Configuration,
  RandomSeed,SeedControl,PRNG,Determinism,Nondeterminism,
  SoftwareEnvironment,OperatingSystem,Compiler,Runtime,Library,
  Dependency,DependencyVersion,LockFile,DependencyLock,
  VirtualEnvironment,Container,ContainerImage,EnvironmentCapture,
  Hardware,CPU,GPU,Precision,FloatingPointPrecision,
  NumericalTolerance,ResultComparison,ToleranceAwareComparison,
  Provenance,DataProvenance,ModelProvenance,ComputationalProvenance,
  Lineage,AuditTrail,Traceability,RunManifest,RunLog,
  RegressionTesting,Benchmark,NumericalVerification,
  ComputationalValidation,ErrorAnalysis,
  BitwiseReproducibility,StatisticalReproducibility,
  CrossPlatformReproducibility,ParallelNondeterminismRelationship,
  ReproducibilityFailure,VersionMismatch,SeedMismatch,
  EnvironmentMismatch,PrecisionMismatch,ReproducibilityReport
 ]
 EXPAND(ReproducibilityFamilies) -> [
  ArtifactAndVersionManagement,
  EnvironmentAndDependencyCapture,
  RandomnessAndDeterminismControl,
  WorkflowAndExecutionReconstruction,
  ProvenanceLineageAndTraceability,
  NumericalStatisticalAndBitwiseComparison,
  CrossPlatformParallelAndDistributedReproducibility,
  FailureDiagnosisEvidenceAndReporting
 ]
 STOP_CONDITION = "Stop when artefacts, versions, environment, randomness, comparison criterion, provenance and reproducibility evidence are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Verification & Validation"
 RELATED_ONTOLOGIES = [
  "Verification & Validation",
  "Numerical Verification Ontology",
  "Computational Validation Ontology",
  "Error Analysis Ontology",
  "Benchmark Ontology",
  "Regression Testing Ontology",
  "Numerical Stability Ontology 2",
  "Floating Point Arithmetic Ontology",
  "Computational Statistics Ontology",
  "Scientific Simulation Ontology",
  "AI Computational Mathematics Ontology",
  "Symbolic Computation",
  "Numerical Linear Algebra Ontology 2",
  "Differential Equation Solver Ontology",
  "Computational Optimisation Ontology",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology"
 ]
 ROUTE_RULES = [
  "Reproducibility -> Verification & Validation for parent evidence semantics",
  "Reproducibility -> Numerical Verification for repeatable numerical-correctness evidence",
  "Reproducibility -> Computational Validation for repeatable validation workflows",
  "Reproducibility -> Error Analysis for tolerance-aware result comparison",
  "Reproducibility -> Benchmark for repeatable benchmark protocols",
  "Reproducibility -> Regression Testing for stable baselines and version comparisons",
  "Reproducibility -> Numerical Stability and Floating Point Arithmetic for precision-sensitive reruns",
  "Reproducibility -> Computational Statistics for stochastic reproducibility",
  "Reproducibility -> Scientific Simulation and AI Computational Mathematics for model, data and workflow lineage",
  "Reproducibility -> Symbolic Computation for deterministic symbolic-output comparison",
  "Reproducibility -> Numerical Linear Algebra, Differential Equation Solvers and Optimisation for solver-specific configuration capture",
  "Reproducibility -> HPC, Parallel, Distributed and GPU Computing for hardware and execution-order reproducibility"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible reproducibility levels, artefact classes or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve reproducibility-versus-correctness distinction.",
  "Preserve repeatability-versus-replicability distinction.",
  "Preserve bitwise-versus-numerical-versus-statistical reproducibility distinction.",
  "Preserve artefact-version-versus-runtime-environment distinction.",
  "Preserve seed-control-versus-determinism distinction.",
  "Preserve provenance-versus-documentation distinction.",
  "Preserve workflow-specification-versus-result-comparison distinction.",
  "Preserve machine-readable reproducibility semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Reproducibility is the ability to regenerate computational results from sufficiently documented, versioned and traceable computational conditions."
 ARTIFACT_SUMMARY = "Code, data, models, parameters and configurations must be versioned or uniquely identified."
 ENVIRONMENT_SUMMARY = "Software, dependencies, compilers, runtimes, hardware and precision settings can materially affect regenerated results."
 RANDOMNESS_SUMMARY = "Seeds and pseudorandom state must be controlled or statistically characterised for stochastic workflows."
 COMPARISON_SUMMARY = "Bitwise, numerical, statistical, structural and semantic reproducibility are distinct comparison levels."
 PROVENANCE_SUMMARY = "Run manifests, hashes, lineage and audit trails provide evidence linking outputs to their computational origins."
 VALIDATION_SUMMARY = "Reproducibility claims should state comparison criteria, tested environments, mismatches, limitations and confidence."
}

FLOW {
 INPUT
 -> detect_reproducibility_context
 -> identify_result_workflow_inputs_data_model_configuration_software_hardware_randomness_and_claimed_reproducibility_level
 -> enumerate_required_code_data_model_dependency_and_configuration_artifacts
 -> resolve_and_lock_relevant_versions
 -> capture_or_reconstruct_runtime_hardware_and_dependency_environment
 -> capture_random_seeds_PRNG_state_and_stochastic_procedures
 -> execute_reproduction_workflow
 -> compare_reference_and_reproduced_results_using_declared_bitwise_numerical_statistical_structural_or_semantic_criteria
 -> if_mismatch_inspect_artifact_version_seed_precision_ordering_cache_hardware_and_environment_differences
 -> preserve_run_manifest_logs_hashes_outputs_and_provenance
 -> assign_reproducibility_status_scope_limitations_and_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-VERIFICATION-VALIDATION-REPRODUCIBILITY-ONTOLOGY-V1"
}

}

END_FLOW