Reproducible Computation Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Reproducible Computation Ontology within the Kireth Research Semantic Library. Reproducible computation concerns designing computational procedures so that declared results can be regenerated from versioned inputs, code, models, parameters, random-state controls, numerical settings, software dependencies and execution environments. This ontology supports deterministic and stochastic computation, environment capture, provenance, workflow manifests, dependency locking, data and model versioning, tolerance-aware comparison, cross-platform execution, checkpointing, auditability, verification and scientific reproducibility.

FLOW_ALGEBRA_RECORD {

METADATA {
 FLOW_NAME = "Reproducible Computation Ontology"
 FLOW_TYPE = "Mathematical Ontology"
 DOMAIN = "Mathematics"
 SUBDOMAIN = "Computational Mathematics"
 SPECIALISATION = "Computational Scientific Workflows / Reproducible Computation"
 CANONICAL_PAGE = "https://kirethframeworkold.co.uk/books/semantic-library/ai-core/ontologies/mathematical-ontologies/computational-mathematics-ontologies/computational-scientific-workflows/reproducible-computation-ontology.html"
 LANGUAGE = "en-GB"
 VERSION = "1.0"
 STATUS = "active"
}

IDENTITY {
 PRIMARY_ENTITY = ReproducibleComputation
 ENTITY_CLASS = ReconstructableScientificComputationFramework
 PRIMARY_CONTEXT = ComputationalScientificWorkflow
 DEFINITION = "Reproducible computation is the practice and formal specification of computational processes so that declared results can be regenerated from preserved and versioned computational artefacts, configurations and environments."
 SYMBOLIC_FORMS = [
  "result = f(code,data,parameters,environment,seed)",
  "reproduce(R_ref) -> R_new ≈ R_ref",
  "manifest = {code,data,config,versions,seed,hardware}",
  "accept if comparison(R_new,R_ref) <= tolerance"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for reconstructable computation, versioned artefacts, random-state control, environment capture, provenance, comparison criteria and reproducibility evidence."
}

SCOPE {
 INCLUDE = [
  ReproducibleComputation,
  ReproducibleWorkflow,
  ReproducibleExecution,
  ReproducibleRun,
  ComputationalReproducibility,
  NumericalReproducibility,
  ScientificReproducibility,
  Repeatability,
  ReplicabilityRelationship,
  ResultRegeneration,
  ResultReconstruction,
  WorkflowReconstruction,
  ExecutionReconstruction,
  ComputationalArtifact,
  CodeArtifact,
  DataArtifact,
  ModelArtifact,
  ConfigurationArtifact,
  EnvironmentArtifact,
  ResultArtifact,
  SourceCode,
  Script,
  NotebookRelationship,
  Executable,
  Binary,
  BuildArtifact,
  RepositoryRelationship,
  Commit,
  Tag,
  Release,
  Version,
  VersionControl,
  Data,
  Dataset,
  RawData,
  ProcessedData,
  DerivedData,
  InputData,
  ValidationData,
  TestData,
  DatasetVersion,
  DataSnapshot,
  DatasetHash,
  Checksum,
  FileHash,
  ContentHash,
  Model,
  ComputationalModel,
  SimulationModel,
  TrainedModelRelationship,
  ModelVersion,
  ModelCheckpointRelationship,
  Parameter,
  ParameterSet,
  HyperparameterRelationship,
  Configuration,
  ConfigurationFile,
  RunConfiguration,
  SolverConfiguration,
  PrecisionConfiguration,
  ToleranceConfiguration,
  WorkflowConfiguration,
  EnvironmentConfiguration,
  CommandLineArgumentRelationship,
  EnvironmentVariable,
  Randomness,
  RandomSeed,
  SeedControl,
  PRNG,
  PseudorandomNumberGenerator,
  RNGStateRelationship,
  DeterministicExecution,
  NondeterministicExecution,
  StochasticExecution,
  RepeatedRun,
  Replicate,
  Trial,
  RunIdentifier,
  ExecutionIdentifier,
  WorkflowRun,
  SoftwareEnvironment,
  RuntimeEnvironment,
  OperatingSystem,
  Compiler,
  CompilerVersion,
  InterpreterRelationship,
  Runtime,
  RuntimeVersion,
  Library,
  LibraryVersion,
  Dependency,
  DependencyVersion,
  Package,
  PackageVersion,
  DependencyGraph,
  LockFile,
  DependencyLock,
  EnvironmentLock,
  RequirementsFileRelationship,
  VirtualEnvironment,
  Container,
  ContainerImage,
  ContainerDigest,
  BuildRecipe,
  ContainerRecipe,
  EnvironmentCapture,
  EnvironmentSnapshot,
  InfrastructureAsCodeRelationship,
  Hardware,
  CPU,
  GPU,
  Accelerator,
  Device,
  Architecture,
  InstructionSetRelationship,
  Driver,
  DriverVersion,
  Memory,
  Storage,
  Network,
  HardwareVersion,
  DevicePlacementRelationship,
  FloatingPointArithmetic,
  FloatingPointPrecision,
  SinglePrecision,
  DoublePrecision,
  MixedPrecision,
  MachinePrecision,
  NumericalTolerance,
  AbsoluteTolerance,
  RelativeTolerance,
  ComparisonTolerance,
  DeterministicReductionRelationship,
  ReductionOrderRelationship,
  ParallelNondeterminismRelationship,
  ThreadSchedulingRelationship,
  RaceConditionRelationship,
  DistributedOrderingRelationship,
  CollectiveCommunicationRelationship,
  BitwiseReproducibility,
  NumericalReproducibilityLevelRelationship,
  StatisticalReproducibility,
  FunctionalReproducibilityRelationship,
  SemanticReproducibilityRelationship,
  CrossPlatformReproducibility,
  CrossHardwareReproducibility,
  CrossCompilerReproducibility,
  CrossLibraryReproducibility,
  ExactComparison,
  BitwiseComparison,
  NumericalComparison,
  ToleranceAwareComparison,
  StatisticalComparison,
  StructuralComparison,
  SemanticComparisonRelationship,
  HashComparison,
  ChecksumVerification,
  ResultDifference,
  AbsoluteDifference,
  RelativeDifference,
  NormDifference,
  DistributionalDifferenceRelationship,
  Provenance,
  ComputationalProvenance,
  WorkflowProvenance,
  DataProvenance,
  ModelProvenance,
  SoftwareProvenance,
  EnvironmentProvenance,
  ResultProvenance,
  Lineage,
  DataLineage,
  ModelLineage,
  WorkflowLineage,
  TransformationHistory,
  AuditTrail,
  Traceability,
  RunManifest,
  WorkflowManifest,
  ExperimentManifestRelationship,
  ProvenanceRecord,
  Metadata,
  MetadataRecord,
  ExecutionLog,
  RunLog,
  ErrorLog,
  ResultLog,
  Documentation,
  MethodsRecord,
  ReproductionReport,
  ReproducibilityReport,
  ArchiveRelationship,
  BackupRelationship,
  PersistentIdentifierRelationship,
  ArtifactRegistryRelationship,
  DataVersioningRelationship,
  ModelRegistryRelationship,
  Cache,
  CacheKey,
  CacheInvalidation,
  StaleCacheRelationship,
  HiddenStateRelationship,
  ExternalServiceDependencyRelationship,
  TimeDependentDependencyRelationship,
  NetworkDependencyRelationship,
  Checkpoint,
  WorkflowCheckpoint,
  StateCheckpoint,
  Restart,
  Resume,
  Recovery,
  Reexecution,
  Rerun,
  Verification,
  Validation,
  NumericalVerification,
  ComputationalValidation,
  ErrorAnalysis,
  Benchmark,
  RegressionTesting,
  ReproducibilityOntologyRelationship,
  VerificationMetrics,
  ValidationMetrics,
  ScientificWorkflow,
  DataPipeline,
  NumericalWorkflow,
  SimulationWorkflow,
  ComputationalExperiment,
  ParameterSweep,
  WorkflowOptimisation,
  ScientificSimulation,
  NumericalLinearAlgebra,
  DifferentialEquationSolver,
  ComputationalOptimisation,
  ComputationalStatistics,
  SymbolicComputation,
  AIComputationalMathematics,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputing,
  AcceptanceCriterion,
  PassCriterion,
  FailCriterion,
  ReproducibilityCriterion,
  Evidence,
  EvidenceStrength,
  Confidence,
  Limitation,
  ReproducibilityFailure,
  MissingDependency,
  VersionMismatch,
  SeedMismatch,
  DataMismatch,
  ModelMismatch,
  EnvironmentMismatch,
  HardwareMismatch,
  PrecisionMismatch,
  ToleranceMismatch,
  NondeterministicMismatch
 ]
 EXCLUDE_AS_PRIMARY = [
  GeneralReproducibilityDiscussionWithoutExecutableComputation,
  BackupOrArchivalWithoutResultRegenerationIntent,
  ValidationWithoutComputationReconstruction,
  PhysicalExperimentReplicationWithoutComputationalWorkflowSemantics
 ]
 DISAMBIGUATION_RULE = "When a computational process is designed or assessed for the ability to regenerate declared results from preserved artefacts and execution conditions, interpret the context as reproducible computation."
}

CORE_CONCEPTS {
 ReproducibleComputation = "Computational process whose results can be regenerated from preserved conditions."
 ComputationalArtifact = "Versioned code, data, model, configuration or environment component required for rerun."
 RunManifest = "Structured record of artefacts and settings used by a computation."
 EnvironmentCapture = "Recording or packaging of software, dependencies, runtime and hardware assumptions."
 SeedControl = "Explicit management of pseudorandom state."
 Provenance = "Traceable lineage linking outputs to computational inputs and transformations."
 ReproducibilityCriterion = "Declared comparison rule used to determine whether regeneration succeeded."
 ReproducibilityFailure = "Failure to regenerate expected computational behaviour within the declared criterion."
}

RELATIONS {
 ReproducibleComputation --is_child_of--> ComputationalScientificWorkflow
 ReproducibleComputation --requires--> VersionedArtifacts
 ReproducibleComputation --requires--> EnvironmentCapture
 ReproducibleComputation --requires--> Provenance
 ReproducibleRun --instantiates--> RunManifest
 RunManifest --references--> CodeDataModelConfigurationAndEnvironment
 SeedControl --constrains--> PseudorandomExecution
 LockFile --constrains--> DependencyVersions
 ContainerImage --encapsulates--> RuntimeEnvironment
 ResultComparison --assesses--> ReproductionAgreement
 WorkflowCheckpoint --supports--> ReexecutionAndRecovery
 Verification --checks--> ReproducedComputationalCorrectness
 Provenance --supports--> TraceableRegeneration
}

OPERATORS {
 EXECUTE(code,data,config,env,seed) := run_computation(code,data,config,env,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)
 REPRODUCE(manifest) := execute_from_manifest(manifest)
 TRACE(result) := provenance_lineage(result)
 COMPARE(result_new,result_ref,criterion) := declared_comparison(result_new,result_ref,criterion)
}

AXIOMS {
 A1 = "Reproducible computation requires enough preserved information to reconstruct execution."
 A2 = "Reproducibility does not imply correctness."
 A3 = "Bitwise reproducibility is stricter than numerical or statistical reproducibility."
 A4 = "Random-state control is necessary but not always sufficient for deterministic reruns."
 A5 = "Dependency and environment changes can alter computational results."
 A6 = "Parallel and distributed execution can introduce nondeterministic floating-point ordering."
 A7 = "A reproducibility claim requires a declared comparison criterion."
 A8 = "Reproducible-computation results require explicit artefact, environment, seed, comparison and provenance semantics."
}

REASONING {
 R1_CONTEXT = identify(target_result,workflow,code,data,model,configuration,randomness,environment_and_claimed_reproducibility_level)
 R2_ARTIFACTS = enumerate_required_code_data_model_configuration_and_dependency_artifacts)
 R3_VERSION = resolve_versions_hashes_commits_and_snapshots)
 R4_ENVIRONMENT = capture_or_reconstruct_software_hardware_runtime_and_dependencies)
 R5_RANDOMNESS = capture_seed_PRNG_state_and_stochastic_control)
 R6_EXECUTE = rerun_computation_from_manifest)
 R7_COMPARE = apply_bitwise_numerical_statistical_structural_or_semantic_criterion)
 R8_DIAGNOSE = if_mismatch inspect_versions_seed_precision_parallel_order_cache_and_environment)
 R9_RECORD = preserve_logs_hashes_manifests_outputs_and_provenance)
 R10_CONCLUDE = assign_reproducibility_status_scope_limitations_and_confidence)
}

CONSTRAINTS {
 C1 = "A fixed seed does not guarantee identical results across all hardware, compilers or libraries."
 C2 = "Floating-point reductions can change with thread or process ordering."
 C3 = "Mutable datasets or external services can invalidate historical reruns."
 C4 = "Unpinned dependencies can silently change behaviour."
 C5 = "Containers do not automatically preserve hardware-level numerical semantics."
 C6 = "Cached outputs can conceal irreproducible underlying computation."
 C7 = "Bitwise equality can be unnecessarily strict for scientifically equivalent numerical results."
 C8 = "Statistical reproducibility requires enough replicates to characterise variability."
 C9 = "Cross-platform reproducibility can require explicitly justified tolerance criteria."
 C10 = "Missing provenance weakens any claim that a result has been reproduced."
}

SEMANTIC_EQUIVALENCE {
 "PseudorandomNumberGenerator" <=> "PRNG"
 "RandomNumberGenerator" <=> "RNG"
 "HighPerformanceComputing" <=> "HPC"
}

VALIDATION {
 V1 = "Code and executable versions are documented."
 V2 = "Input data and dataset versions are documented."
 V3 = "Model, parameters and configurations are documented."
 V4 = "Dependency and runtime versions are documented."
 V5 = "Random seeds and stochastic procedures are documented."
 V6 = "Numerical precision and comparison tolerances are documented."
 V7 = "Hardware-sensitive settings are documented when material."
 V8 = "Run manifests, hashes and provenance are retained."
 V9 = "Reproduction failures record observed mismatch causes where known."
 V10 = "Reproducibility conclusions state tested environments, comparison criteria and limitations."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 REPRODUCIBLE_COMPUTATION_DEFINITION = 0.99
 ARTIFACT_REASONING = 0.99
 ENVIRONMENT_REASONING = 0.99
 SEED_REASONING = 0.99
 CROSS_PLATFORM_REASONING = 0.97
 PARALLEL_REPRODUCIBILITY_REASONING = 0.97
 POLICY = "Reduce confidence when artefact versions, random-state handling, environment, hardware, precision, external dependencies or provenance are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,ReproducibleComputationReasoning,
  ArtifactVersioningReasoning,RunManifestReasoning,
  EnvironmentCaptureReasoning,DependencyLockingReasoning,
  SeedControlReasoning,BitwiseReproducibilityReasoning,
  NumericalReproducibilityReasoning,StatisticalReproducibilityReasoning,
  CrossPlatformReasoning,ParallelNondeterminismReasoning,
  ProvenanceReasoning,LineageReasoning,
  ReproducibilityFailureReasoning,VerificationReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "reproducible computation" -> ReproducibleComputation
  "computational reproducibility" -> ComputationalReproducibility
  "PRNG" -> PseudorandomNumberGenerator
  "RNG" -> RandomNumberGenerator
  "HPC" -> HighPerformanceComputing
 }
}

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

RECURSION {
 ENTRY = ReproducibleComputation
 EXPAND(ReproducibleComputation) -> [
  ReproducibleWorkflow,ReproducibleExecution,ReproducibleRun,
  ComputationalReproducibility,NumericalReproducibility,
  Repeatability,ReplicabilityRelationship,ResultRegeneration,
  ComputationalArtifact,CodeArtifact,DataArtifact,ModelArtifact,
  ConfigurationArtifact,EnvironmentArtifact,SourceCode,
  RepositoryRelationship,Commit,VersionControl,Dataset,
  DatasetVersion,DataSnapshot,DatasetHash,Model,ModelVersion,
  ParameterSet,Configuration,RunConfiguration,RandomSeed,
  SeedControl,PRNG,DeterministicExecution,NondeterministicExecution,
  SoftwareEnvironment,OperatingSystem,Compiler,Runtime,Library,
  Dependency,DependencyVersion,LockFile,DependencyLock,
  VirtualEnvironment,Container,ContainerImage,EnvironmentCapture,
  CPU,GPU,HardwareVersion,FloatingPointPrecision,
  NumericalTolerance,BitwiseReproducibility,
  StatisticalReproducibility,CrossPlatformReproducibility,
  ToleranceAwareComparison,HashComparison,Provenance,
  ComputationalProvenance,DataProvenance,ModelProvenance,
  WorkflowProvenance,Lineage,AuditTrail,RunManifest,
  WorkflowManifest,ExecutionLog,Documentation,
  Checkpoint,Restart,Reexecution,Verification,
  NumericalVerification,ComputationalValidation,ErrorAnalysis,
  Benchmark,RegressionTesting,VerificationMetrics,
  ValidationMetrics,ScientificWorkflow,DataPipeline,
  NumericalWorkflow,SimulationWorkflow,ComputationalExperiment,
  ParameterSweep,WorkflowOptimisation,ReproducibilityFailure
 ]
 EXPAND(ReproducibleComputationFamilies) -> [
  ArtifactVersioningAndIdentity,
  EnvironmentDependencyAndHardwareCapture,
  RandomnessSeedAndDeterminismControl,
  ManifestsWorkflowReconstructionAndRerun,
  BitwiseNumericalStatisticalAndSemanticComparison,
  ProvenanceLineageAndAuditability,
  CrossPlatformParallelAndDistributedReproducibility,
  FailureDiagnosisVerificationAndEvidenceReporting
 ]
 STOP_CONDITION = "Stop when artefacts, versions, environment, randomness, comparison criterion, provenance and reproducibility evidence are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Scientific Workflows"
 RELATED_ONTOLOGIES = [
  "Computational Scientific Workflows",
  "Scientific Workflow Ontology",
  "Data Pipeline Ontology",
  "Numerical Workflow Ontology",
  "Simulation Workflow Ontology",
  "Computational Experiment Ontology",
  "Parameter Sweep Ontology",
  "Workflow Optimisation Ontology",
  "Verification & Validation",
  "Reproducibility Ontology",
  "Regression Testing Ontology",
  "Benchmark Ontology",
  "Numerical Verification Ontology",
  "Error Analysis Ontology",
  "Computational Statistics Ontology",
  "Scientific Simulation Ontology",
  "AI Computational Mathematics Ontology",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology"
 ]
 ROUTE_RULES = [
  "Reproducible Computation -> Computational Scientific Workflows for parent orchestration semantics",
  "Reproducible Computation -> Scientific Workflow for task and workflow-definition semantics",
  "Reproducible Computation -> Data Pipeline for input-data lineage and versioning",
  "Reproducible Computation -> Numerical and Simulation Workflows for method, solver and precision capture",
  "Reproducible Computation -> Computational Experiment and Parameter Sweep for experiment manifests and seed control",
  "Reproducible Computation -> Workflow Optimisation for preserving reproducibility after schedule or resource changes",
  "Reproducible Computation -> Verification & Validation and Reproducibility Ontology for evidence and acceptance semantics",
  "Reproducible Computation -> Regression Testing and Benchmark for stable rerun protocols",
  "Reproducible Computation -> Computational Statistics for stochastic reproducibility",
  "Reproducible Computation -> Scientific Simulation and AI Computational Mathematics for model and dataset lineage",
  "Reproducible Computation -> HPC, Parallel, Distributed and GPU Computing for execution-order and hardware reproducibility"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible reproducibility methods, artefact classes or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve reproducibility-versus-correctness distinction.",
  "Preserve artefact-identity-versus-runtime-environment distinction.",
  "Preserve seed-control-versus-determinism distinction.",
  "Preserve bitwise-versus-numerical-versus-statistical reproducibility distinction.",
  "Preserve workflow-definition-versus-workflow-run distinction.",
  "Preserve provenance-versus-documentation distinction.",
  "Preserve rerun-success-versus-scientific-validity distinction.",
  "Preserve machine-readable reproducible-computation semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "Reproducible computation is the design and execution of computational processes so that declared results can be regenerated from preserved, versioned and traceable conditions."
 ARTIFACT_SUMMARY = "Code, data, models, parameters, configurations and dependencies must be uniquely identified or versioned."
 ENVIRONMENT_SUMMARY = "Runtime, libraries, compilers, hardware and precision settings can materially affect regenerated results."
 RANDOMNESS_SUMMARY = "Seeds and pseudorandom state must be controlled or statistically characterised."
 COMPARISON_SUMMARY = "Bitwise, numerical, statistical, structural and semantic reproducibility are distinct evidence levels."
 PROVENANCE_SUMMARY = "Run manifests, hashes, lineage and audit trails connect results to their computational origins."
 VALIDATION_SUMMARY = "Reproducible computations should state comparison criteria, achieved reproducibility level, tested environment, mismatches, limitations and verification status."
}

FLOW {
 INPUT
 -> detect_reproducible_computation_context
 -> identify_target_result_workflow_code_data_model_configuration_randomness_environment_and_claimed_reproducibility_level
 -> enumerate_required_code_data_model_configuration_dependency_and_environment_artifacts
 -> resolve_versions_hashes_commits_snapshots_and_lockfiles
 -> capture_or_reconstruct_runtime_hardware_compiler_library_and_dependency_environment
 -> capture_random_seed_PRNG_state_and_stochastic_procedures
 -> construct_run_manifest
 -> execute_reproduction_run
 -> compare_reference_and_reproduced_results_using_declared_bitwise_numerical_statistical_structural_or_semantic_criterion
 -> if_mismatch_inspect_version_seed_precision_parallel_order_cache_hardware_and_environment_differences
 -> preserve_logs_hashes_results_manifests_and_provenance
 -> assign_reproducibility_status_scope_limitations_and_confidence
 -> package_all_artifacts_for_future_rerun
 -> 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-SCIENTIFIC-WORKFLOWS-REPRODUCIBLE-COMPUTATION-ONTOLOGY-V1"
}

}

END_FLOW