Data Pipeline Ontology

AI INTERPRETATION NOTE
This Flow Algebra defines the Data Pipeline Ontology within the Kireth Research Semantic Library. A data pipeline is a structured computational process that ingests, validates, transforms, enriches, partitions, stores and delivers data between scientific workflow stages under explicit schema, dependency, provenance, quality, reproducibility and execution semantics. This ontology supports batch and streaming pipelines, ETL and ELT relationships, data validation, schema evolution, lineage, partitioning, caching, orchestration, retries, checkpointing, quality gates, distributed processing, reproducibility and downstream scientific computation.

FLOW_ALGEBRA_RECORD {

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

IDENTITY {
 PRIMARY_ENTITY = DataPipeline
 ENTITY_CLASS = ScientificDataTransformationAndDeliveryFramework
 PRIMARY_CONTEXT = ComputationalScientificWorkflow
 DEFINITION = "A data pipeline is a structured computational workflow that moves data through ordered ingestion, validation, transformation, enrichment, storage and delivery stages."
 SYMBOLIC_FORMS = [
  "D_0 -> ingest -> validate -> transform -> D_n",
  "stage_j(input_j,config_j) -> output_j",
  "schema(output_i) compatible_with schema(input_j)",
  "pipeline_result = execute(P,data,config,environment)"
 ]
 SEMANTIC_ROLE = "Provides machine-readable semantics for data ingestion, transformation, schema validation, partitioning, storage, lineage, quality, orchestration, reproducibility and delivery into scientific computation."
}

SCOPE {
 INCLUDE = [
  DataPipeline,
  ScientificDataPipeline,
  ComputationalDataPipeline,
  Pipeline,
  ETLrelationship,
  ELTrelationship,
  BatchPipeline,
  StreamingPipeline,
  MicroBatchPipelineRelationship,
  EventDrivenPipelineRelationship,
  RealTimePipelineRelationship,
  NearRealTimePipelineRelationship,
  Ingestion,
  DataIngestion,
  BatchIngestion,
  StreamIngestion,
  FileIngestion,
  APIIngestionRelationship,
  DatabaseIngestionRelationship,
  SensorIngestionRelationship,
  MessageIngestionRelationship,
  DataSource,
  SourceSystem,
  InputDataset,
  RawData,
  LandingZoneRelationship,
  StagingArea,
  IntermediateData,
  ProcessedData,
  CuratedData,
  DerivedData,
  OutputDataset,
  Sink,
  TargetSystem,
  DataDestination,
  DataLakeRelationship,
  DataWarehouseRelationship,
  ObjectStorageRelationship,
  FileSystemRelationship,
  DatabaseRelationship,
  TableRelationship,
  DataFrameRelationship,
  Record,
  Row,
  Column,
  Field,
  Attribute,
  Key,
  PrimaryKeyRelationship,
  ForeignKeyRelationship,
  Identifier,
  Schema,
  DataSchema,
  InputSchema,
  OutputSchema,
  SchemaValidation,
  SchemaCompatibility,
  SchemaEvolution,
  SchemaVersion,
  SchemaMigrationRelationship,
  TypeSystem,
  DataType,
  ScalarType,
  VectorTypeRelationship,
  StructuredData,
  SemiStructuredData,
  UnstructuredData,
  TabularData,
  TimeSeriesData,
  SpatialDataRelationship,
  GraphDataRelationship,
  TensorDataRelationship,
  MissingValue,
  NullValue,
  NaNRelationship,
  InvalidValue,
  Outlier,
  Duplicate,
  CorruptRecord,
  MalformedRecord,
  DataValidation,
  DataQuality,
  QualityRule,
  QualityCheck,
  Completeness,
  Validity,
  Consistency,
  Uniqueness,
  AccuracyRelationship,
  TimelinessRelationship,
  FreshnessRelationship,
  RangeCheck,
  DomainCheck,
  TypeCheck,
  FormatCheck,
  ConstraintCheck,
  ReferentialIntegrityRelationship,
  DuplicateCheck,
  MissingValueCheck,
  OutlierCheck,
  StatisticalQualityCheckRelationship,
  DataCleaning,
  Filtering,
  Deduplication,
  Imputation,
  MissingValueHandling,
  OutlierHandling,
  Normalisation,
  Standardisation,
  Scaling,
  EncodingRelationship,
  DecodingRelationship,
  Parsing,
  TokenisationRelationship,
  DataTransformation,
  MapOperation,
  FilterOperation,
  ReduceOperation,
  AggregateOperation,
  GroupByRelationship,
  Join,
  Merge,
  Union,
  Concatenation,
  Sort,
  Order,
  WindowOperationRelationship,
  PivotRelationship,
  UnpivotRelationship,
  Reshape,
  Projection,
  Selection,
  FeatureExtractionRelationship,
  FeatureEngineeringRelationship,
  Enrichment,
  Lookup,
  ReferenceDataJoinRelationship,
  GeospatialEnrichmentRelationship,
  TimestampEnrichmentRelationship,
  UnitConversionRelationship,
  DataConversion,
  FormatConversion,
  Serialization,
  Deserialization,
  Compression,
  Decompression,
  EncodingFormat,
  CSVRelationship,
  JSONRelationship,
  XMLRelationship,
  ParquetRelationship,
  BinaryFormatRelationship,
  Partition,
  Partitioning,
  RangePartitioning,
  HashPartitioning,
  TimePartitioning,
  SpatialPartitioningRelationship,
  Shard,
  Sharding,
  BucketingRelationship,
  Repartitioning,
  CoPartitioningRelationship,
  SortPartitionRelationship,
  DataLocality,
  LocalityAwareProcessing,
  DataMovement,
  DataTransfer,
  Shuffle,
  NetworkTransfer,
  DiskIORelationship,
  MemoryIOrelationship,
  Cache,
  Caching,
  CacheKey,
  CacheInvalidation,
  Materialisation,
  LazyEvaluationRelationship,
  EagerEvaluationRelationship,
  Checkpoint,
  PipelineCheckpoint,
  Offset,
  StreamOffsetRelationship,
  WatermarkRelationship,
  EventTimeRelationship,
  ProcessingTimeRelationship,
  Window,
  TumblingWindowRelationship,
  SlidingWindowRelationship,
  SessionWindowRelationship,
  LateDataRelationship,
  Backfill,
  Replay,
  Reprocessing,
  IncrementalProcessing,
  FullRefresh,
  ChangeDataCaptureRelationship,
  CDCRelationship,
  UpsertRelationship,
  Idempotence,
  ExactlyOnceRelationship,
  AtLeastOnceRelationship,
  AtMostOnceRelationship,
  DeliverySemantics,
  OrderingGuaranteeRelationship,
  PipelineStage,
  Stage,
  PipelineTask,
  Task,
  Job,
  Dependency,
  StageDependency,
  DataDependency,
  ControlDependency,
  SourceStage,
  SinkStage,
  TransformationStage,
  ValidationStage,
  QualityGate,
  Orchestration,
  PipelineOrchestration,
  WorkflowEngine,
  PipelineEngine,
  Scheduler,
  TaskScheduler,
  ResourceScheduler,
  StaticScheduling,
  DynamicScheduling,
  Trigger,
  TimeTriggerRelationship,
  EventTriggerRelationship,
  DataArrivalTriggerRelationship,
  ConditionalTriggerRelationship,
  Execution,
  PipelineRun,
  JobRun,
  TaskRun,
  RunIdentifier,
  ExecutionState,
  Pending,
  Running,
  Completed,
  Failed,
  Retried,
  Cancelled,
  Skipped,
  Blocked,
  Retry,
  RetryPolicy,
  RetryLimit,
  Timeout,
  Failure,
  TaskFailure,
  DataFailure,
  SchemaFailure,
  QualityFailure,
  NetworkFailure,
  StorageFailure,
  ResourceFailure,
  Recovery,
  Restart,
  Resume,
  CheckpointRecovery,
  FaultTolerance,
  Resilience,
  DeadLetterQueueRelationship,
  ErrorRecord,
  QuarantineRelationship,
  Provenance,
  DataProvenance,
  PipelineProvenance,
  ComputationalProvenance,
  Lineage,
  DataLineage,
  ColumnLineageRelationship,
  TransformationLineage,
  SourceToTargetLineage,
  AuditTrail,
  Traceability,
  RunManifest,
  ExecutionLog,
  ErrorLog,
  QualityReport,
  DataProfileRelationship,
  Reproducibility,
  Repeatability,
  EnvironmentCapture,
  PipelineVersion,
  SchemaVersion,
  DatasetVersion,
  TransformationVersion,
  LibraryVersion,
  ImplementationVersion,
  Configuration,
  ConfigurationFile,
  Parameter,
  PipelineParameter,
  EnvironmentVariable,
  SecretReferenceRelationship,
  CredentialReferenceRelationship,
  AccessControlRelationship,
  ParallelProcessing,
  DistributedProcessing,
  TaskParallelism,
  DataParallelism,
  HighPerformanceComputing,
  ParallelComputing,
  DistributedComputing,
  GPUComputingRelationship,
  ClusterComputing,
  Scalability,
  Throughput,
  Latency,
  ProcessingRate,
  RecordsPerSecondRelationship,
  BatchSize,
  PartitionCount,
  WorkerCount,
  MemoryUsage,
  StorageUsage,
  NetworkBandwidth,
  CommunicationCost,
  ComputationCost,
  PipelineOverhead,
  BackpressureRelationship,
  QueueLengthRelationship,
  Bottleneck,
  CriticalPath,
  PerformanceScaling,
  ScientificWorkflow,
  ComputationalScientificWorkflow,
  ScientificSimulation,
  DifferentialEquationSolver,
  ComputationalStatistics,
  AIComputationalMathematics,
  SymbolicComputation,
  NumericalLinearAlgebra,
  ComputationalOptimisation,
  ComputationalDataStructures,
  SparseDataStructure,
  DenseDataStructure,
  VectorComputation,
  MatrixComputation,
  TensorComputation,
  Verification,
  Validation,
  NumericalVerification,
  ComputationalValidation,
  ErrorAnalysis,
  Benchmark,
  RegressionTesting,
  ReproducibilityOntologyRelationship,
  VerificationMetrics,
  ValidationMetrics
 ]
 EXCLUDE_AS_PRIMARY = [
  GeneralBusinessETLWithoutScientificOrComputationalContext,
  SingleFileTransformationWithoutPipelineSemantics,
  PureDatabaseAdministrationWithoutDataflowTransformationContext,
  HumanDataEntryProcessWithoutExecutableComputationalStages
 ]
 DISAMBIGUATION_RULE = "When data is moved through multiple computational ingestion, validation, transformation or delivery stages under explicit dependency and provenance semantics, interpret the context as a data pipeline."
}

CORE_CONCEPTS {
 DataPipeline = "Structured process for moving and transforming data through computational stages."
 Ingestion = "Acquisition of data from a source into the pipeline."
 DataTransformation = "Operation that changes data representation, structure or values."
 DataValidation = "Checking data against schema, quality and constraint rules."
 Schema = "Declared structural and type definition for pipeline data."
 Partitioning = "Division of data into independently processable subsets."
 DataLineage = "Traceable path from source data through transformations to outputs."
 DeliverySemantics = "Guarantee governing whether records are processed zero, one or multiple times."
}

RELATIONS {
 DataPipeline --is_child_of--> ComputationalScientificWorkflow
 DataPipeline --contains--> PipelineStages
 PipelineStage --consumes--> InputData
 PipelineStage --produces--> OutputData
 DataDependency --connects--> UpstreamAndDownstreamStages
 Ingestion --reads_from--> DataSource
 DataValidation --checks--> DataAgainstSchemaAndQualityRules
 DataTransformation --changes--> DataRepresentation
 Partitioning --enables--> ParallelProcessing
 DataLineage --records--> SourceTransformationAndDestination
 Checkpointing --supports--> Recovery
 Reproducibility --requires--> VersionedPipelineArtifacts
 Verification --checks--> PipelineCorrectness
}

OPERATORS {
 INGEST(source) := read_data(source)
 VALIDATE(data,schema,rules) := check(data,schema,rules)
 TRANSFORM(data,f) := map_or_apply(f,data)
 PARTITION(data,key,n) := split(data,key,n)
 AGGREGATE(data,g) := grouped_reduce(data,g)
 WRITE(data,sink) := persist(data,sink)
 CHECKPOINT(state) := persist_pipeline_state(state)
 TRACE(record) := source_to_target_lineage(record)
}

AXIOMS {
 A1 = "A data pipeline consists of ordered or dependency-constrained data-processing stages."
 A2 = "Each stage requires declared input and output schemas or equivalent structural contracts."
 A3 = "Data-quality failures should be distinguishable from execution failures."
 A4 = "Distributed data processing requires explicit partitioning and movement semantics."
 A5 = "Delivery guarantees affect correctness under retries and failures."
 A6 = "Schema evolution must preserve or explicitly migrate downstream compatibility."
 A7 = "Pipeline reproducibility requires versioned data, transformations, configuration and environment."
 A8 = "Data-pipeline results require explicit schema, transformation, quality, lineage, execution and reproducibility semantics."
}

REASONING {
 R1_CONTEXT = identify(sources,sinks,schemas,transformation_goal,volume,velocity,quality_requirements_and_consumers)
 R2_DESIGN = define_pipeline_stages_dependencies_interfaces_and_delivery_semantics)
 R3_SCHEMA = define_input_output_schemas_types_constraints_and_evolution_policy)
 R4_QUALITY = define_validation_completeness_uniqueness_range_and_consistency_checks)
 R5_EXECUTION = choose_batch_streaming_incremental_or_hybrid_processing)
 R6_SCALE = choose_partitioning_parallelism_caching_and_data_locality_strategy)
 R7_RECOVERY = define_checkpoint_retry_replay_backfill_and_failure_quarantine_semantics)
 R8_LINEAGE = record_source_to_target_transformation_and_version_provenance)
 R9_VERIFY = execute_quality_checks_row_counts_invariants_and_reconciliation)
 R10_REPRODUCE = document_pipeline_versions_data_versions_configuration_and_environment)
}

CONSTRAINTS {
 C1 = "Schema mismatch can silently corrupt downstream computations if not checked."
 C2 = "Retries can duplicate data when pipeline stages are not idempotent."
 C3 = "At-least-once delivery can produce duplicates without deduplication or idempotent sinks."
 C4 = "Exactly-once claims depend on source, processing and sink semantics."
 C5 = "Distributed shuffles can dominate runtime and network cost."
 C6 = "Late or out-of-order streaming data require explicit event-time semantics."
 C7 = "Backfills can change historical outputs and must preserve lineage."
 C8 = "Mutable source datasets weaken reproducibility unless versioned or snapshotted."
 C9 = "Quality checks can pass while semantic errors remain in the data."
 C10 = "Pipeline performance optimisations must not change declared data semantics."
}

SEMANTIC_EQUIVALENCE {
 "ChangeDataCapture" <=> "CDC"
 "ExtractTransformLoad" <=> "ETL"
 "ExtractLoadTransform" <=> "ELT"
 "DirectedAcyclicGraphWorkflow" <=> "DAGWorkflow"
}

VALIDATION {
 V1 = "Sources and sinks are documented."
 V2 = "Input and output schemas are documented."
 V3 = "Transformation rules are versioned."
 V4 = "Data-quality checks and failure policies are documented."
 V5 = "Partitioning and ordering semantics are explicit."
 V6 = "Delivery guarantees are documented."
 V7 = "Retry, replay and checkpoint behaviour are documented."
 V8 = "Lineage links outputs to sources and transformations."
 V9 = "Pipeline metrics and bottlenecks are monitored where relevant."
 V10 = "Pipeline reruns are reproducible under documented data, code, schema, configuration and environment versions."
}

CONFIDENCE {
 BASE_CONFIDENCE = 0.99
 DATA_PIPELINE_DEFINITION = 0.99
 SCHEMA_REASONING = 0.99
 DATA_QUALITY_REASONING = 0.99
 PARTITIONING_REASONING = 0.98
 DELIVERY_SEMANTICS_REASONING = 0.98
 STREAMING_REASONING = 0.98
 LINEAGE_REASONING = 0.99
 POLICY = "Reduce confidence when schema, quality rules, delivery guarantees, ordering, partitioning, lineage or source versioning are underspecified."
}

AI_CONSUMPTION {
 PURPOSES = [
  SemanticSearch,OntologyGrounding,DataPipelineReasoning,
  IngestionReasoning,SchemaReasoning,DataValidationReasoning,
  DataQualityReasoning,TransformationReasoning,
  PartitioningReasoning,StreamingReasoning,
  BatchProcessingReasoning,DeliverySemanticsReasoning,
  CheckpointingReasoning,FaultToleranceReasoning,
  DataLineageReasoning,ReproducibilityReasoning,
  VerificationReasoning,ScientificWorkflowReasoning,
  KnowledgeGraphConstruction,RetrievalAugmentation,RecursiveInference
 ]
 NORMALISE {
  "data pipeline" -> DataPipeline
  "scientific data pipeline" -> ScientificDataPipeline
  "CDC" -> ChangeDataCapture
  "ETL" -> ExtractTransformLoad
  "ELT" -> ExtractLoadTransform
 }
}

EXECUTION_RULES {
 E1 = "If data moves through multiple computational processing stages, activate DataPipelineOntology."
 E2 = "Define source, sink, schemas and stage interfaces before execution."
 E3 = "Validate incoming data before dependent scientific computation."
 E4 = "Separate data-quality failures from infrastructure or task failures."
 E5 = "Use partitioning and parallelism only with explicit ordering and aggregation semantics."
 E6 = "Define checkpoint, retry, replay and backfill behaviour for recoverable pipelines."
 E7 = "Preserve lineage through every transformation stage."
 E8 = "Apply quality gates before publishing data to downstream scientific workflows."
 E9 = "Version data, transformations, schema and environment for reproducibility."
}

RECURSION {
 ENTRY = DataPipeline
 EXPAND(DataPipeline) -> [
  ScientificDataPipeline,ComputationalDataPipeline,Pipeline,
  BatchPipeline,StreamingPipeline,Ingestion,DataSource,RawData,
  StagingArea,ProcessedData,CuratedData,OutputDataset,Sink,
  Schema,InputSchema,OutputSchema,SchemaValidation,
  SchemaCompatibility,SchemaEvolution,DataType,
  DataValidation,DataQuality,QualityRule,Completeness,
  Validity,Consistency,Uniqueness,RangeCheck,DuplicateCheck,
  MissingValueCheck,DataCleaning,Filtering,Deduplication,
  Imputation,Normalisation,DataTransformation,MapOperation,
  FilterOperation,AggregateOperation,Join,Merge,Sort,
  Enrichment,FormatConversion,Serialization,Partitioning,
  HashPartitioning,TimePartitioning,Sharding,DataLocality,
  DataMovement,Shuffle,Caching,Materialisation,
  Checkpoint,Backfill,Replay,IncrementalProcessing,
  ChangeDataCapture,CDC,Idempotence,ExactlyOnceRelationship,
  AtLeastOnceRelationship,PipelineStage,StageDependency,
  DataDependency,QualityGate,PipelineOrchestration,
  Scheduler,PipelineRun,Retry,Failure,Recovery,FaultTolerance,
  DataProvenance,PipelineProvenance,DataLineage,
  SourceToTargetLineage,AuditTrail,Reproducibility,
  PipelineVersion,SchemaVersion,DatasetVersion,
  ParallelProcessing,DistributedProcessing,Scalability,
  Throughput,Latency,BackpressureRelationship,
  ScientificWorkflow,ComputationalScientificWorkflow,
  NumericalVerification,ComputationalValidation,
  ErrorAnalysis,Benchmark,RegressionTesting,
  VerificationMetrics,ValidationMetrics
 ]
 EXPAND(DataPipelineFamilies) -> [
  DataIngestionAndSourceSemantics,
  SchemaValidationAndEvolution,
  CleaningTransformationAndEnrichment,
  PartitioningMovementAndDistributedProcessing,
  BatchStreamingAndIncrementalExecution,
  DeliveryCheckpointReplayAndFaultRecovery,
  QualityLineageAndProvenance,
  ReproducibilityVerificationAndWorkflowIntegration
 ]
 STOP_CONDITION = "Stop when sources, schemas, transformations, quality, execution, delivery, lineage and reproducibility are sufficiently resolved."
}

ROUTING {
 PARENT_ONTOLOGY = "Computational Scientific Workflows"
 RELATED_ONTOLOGIES = [
  "Computational Scientific Workflows",
  "Scientific Workflow Ontology",
  "Verification & Validation",
  "Reproducibility Ontology",
  "Benchmark Ontology",
  "Regression Testing Ontology",
  "Scientific Simulation Ontology",
  "Computational Statistics Ontology",
  "AI Computational Mathematics Ontology",
  "Computational Data Structures",
  "Graph Algorithms Ontology",
  "High Performance Computing Ontology 2",
  "Parallel Computing Ontology",
  "Distributed Computing Ontology",
  "GPU Computing Ontology"
 ]
 ROUTE_RULES = [
  "Data Pipeline -> Computational Scientific Workflows for parent orchestration semantics",
  "Data Pipeline -> Scientific Workflow Ontology for task and dependency semantics",
  "Data Pipeline -> Verification & Validation for data-quality and correctness gates",
  "Data Pipeline -> Reproducibility for data, schema and transformation versioning",
  "Data Pipeline -> Benchmark and Regression Testing for repeatable pipeline comparison",
  "Data Pipeline -> Scientific Simulation and Computational Statistics for scientific data consumers",
  "Data Pipeline -> AI Computational Mathematics for training, validation and inference datasets",
  "Data Pipeline -> Computational Data Structures and Graph Algorithms for internal data and dependency representations",
  "Data Pipeline -> HPC, Parallel, Distributed and GPU Computing for scalable data processing"
 ]
}

UPDATE_MODEL {
 MODE = "append-compatible semantic versioning"
 MAJOR = "ontology-breaking conceptual change"
 MINOR = "new compatible pipeline stages, quality rules or reasoning pathways"
 PATCH = "clarification, metadata or formatting correction"
 RULES = [
  "Preserve source-versus-sink distinction.",
  "Preserve raw-versus-processed-versus-curated data distinction.",
  "Preserve schema-validation-versus-data-quality distinction.",
  "Preserve data-dependency-versus-control-dependency distinction.",
  "Preserve batch-versus-streaming execution distinction.",
  "Preserve at-most-once-versus-at-least-once-versus-exactly-once distinction.",
  "Preserve lineage-versus-log-output distinction.",
  "Preserve machine-readable data-pipeline semantics."
 ]
}

OUTPUT {
 CANONICAL_DEFINITION = "A data pipeline is a structured workflow that ingests, validates, transforms, partitions, stores and delivers data under explicit schema, quality, lineage and execution semantics."
 INGESTION_SUMMARY = "Sources, ingestion methods and raw-data boundaries define how data enters the pipeline."
 TRANSFORMATION_SUMMARY = "Cleaning, filtering, joining, aggregation and enrichment convert raw inputs into scientifically usable outputs."
 QUALITY_SUMMARY = "Schema, completeness, validity, consistency, uniqueness and constraint checks provide explicit quality gates."
 EXECUTION_SUMMARY = "Batch, streaming, incremental and distributed execution require explicit partitioning, ordering and delivery semantics."
 LINEAGE_SUMMARY = "Data lineage records how every output depends on source data, transformations, versions and configuration."
 VALIDATION_SUMMARY = "Scientific data pipelines should be reproducible, quality-controlled, fault-aware and traceable before their outputs are consumed by downstream computational workflows."
}

FLOW {
 INPUT
 -> detect_data_pipeline_context
 -> identify_sources_sinks_schemas_transformation_goal_volume_velocity_quality_requirements_and_consumers
 -> define_pipeline_stages_dependencies_interfaces_and_delivery_semantics
 -> define_input_output_schemas_types_constraints_and_evolution_policy
 -> configure_data_validation_completeness_uniqueness_range_consistency_and_quality_rules
 -> choose_batch_streaming_incremental_or_hybrid_processing
 -> apply_cleaning_filtering_joining_aggregation_enrichment_and_format_transformations
 -> choose_partitioning_parallelism_caching_and_data_locality_strategy
 -> define_checkpoint_retry_replay_backfill_and_failure_quarantine_semantics
 -> execute_pipeline_and_capture_quality_metrics_logs_and_intermediate_state
 -> record_source_to_target_lineage_versions_configuration_and_provenance
 -> apply_quality_and_verification_gates_before_downstream_delivery
 -> package_versioned_pipeline_artifacts_for_reproducible_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-DATA-PIPELINE-ONTOLOGY-V1"
}

}

END_FLOW