Process Dependency Ontology

FLOW ALGEBRA
TITLE: Process Dependency Ontology
DOMAIN: Relationship Ontologies / Process Relationships
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/process-relationships/process-dependency-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "ProcessDependencyOntology" v1.0 {
  ontology:
    id: "process-dependency-ontology"
    parent: "process-relationships"
    purpose: "Represent, validate and reason about prerequisites, resources, information flows and execution dependencies among processes and activities."

  types:
    Process: {id: string, name: string, state: enum[planned, ready, running, completed, failed, cancelled], version: string?}
    Activity: {id: string, process_id: string, name: string, state: string}
    Resource: {id: string, kind: string, capacity: number?, unit: string?}
    Artefact: {id: string, kind: string, version: string?, provenance: string?}
    Condition: {id: string, expression: string, evaluation_context: string?}
    Dependency: {id: string, dependent_id: string, prerequisite_id: string, kind: enum[finish_to_start, start_to_start, finish_to_finish, start_to_finish, data, resource, conditional], mandatory: bool, condition_id: string?, lag: number?, lag_unit: string?, confidence: number, evidence: string[]}
    Observation: {id: string, timestamp: datetime, source: string, provenance: string}

  predicates:
    depends_on(dependent: Process|Activity, prerequisite: Process|Activity)
    requires_resource(activity: Activity, resource: Resource)
    consumes(activity: Activity, artefact: Artefact)
    produces(activity: Activity, artefact: Artefact)
    guarded_by(dependency: Dependency, condition: Condition)
    precedes(prerequisite: Process|Activity, dependent: Process|Activity)
    blocks(prerequisite: Process|Activity, dependent: Process|Activity)
    impacts(upstream: Process|Activity, downstream: Process|Activity)

  constraints:
    - "Dependency endpoints must resolve to valid typed process or activity identifiers."
    - "Direction is dependent -> prerequisite; do not reverse it when evaluating execution order."
    - "Confidence must lie within [0,1] and evidence must retain provenance."
    - "Dependency kind determines start/finish constraints; generic depends_on does not always imply finish-to-start."
    - "Cycles in mandatory finish-to-start prerequisites must be flagged unless explicitly modelled as bounded iteration."
    - "Conditional dependencies are active only when their guards evaluate true in a specified context."
    - "Missing resources or artefacts must not be treated as available without supporting observations."
    - "Temporal precedence alone does not establish a dependency or causation."

  inference:
    rule prerequisite_blocking:
      if mandatory_finish_to_start(d,p) and not completed(p)
      then blocked(d)
      confidence: "evidence-backed status; distinguish unknown from incomplete"
    rule transitive_prerequisites:
      if mandatory_finish_to_start(a,b) and mandatory_finish_to_start(b,c) and acyclic_path(a,b,c)
      then indirect_prerequisite(a,c)
      confidence: "retain complete dependency path and weakest supporting evidence"
    rule data_dependency:
      if produces(a,x) and consumes(b,x) and same_artefact_version(x)
      then candidate_data_dependency(b,a)
      confidence: "candidate only until workflow linkage is validated"
    rule change_impact:
      if impacts(a,b) and impacts(b,c) and valid_dependency_path(a,b,c)
      then candidate_impact(a,c)
      confidence: "do not infer certain failure from potential impact"

  SEMANTIC_EQUIVALENCE:
    - "Map process and dependency labels to versioned canonical identifiers."
    - "Distinguish prerequisite, scheduling order, causal influence, resource competition and data flow."
    - "Do not merge similarly named activities without identity and execution-context evidence."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, dependency_observation, workflow_version, temporal_validity, condition_certainty, independent_verification]
    policy: "Retain uncertainty and provenance; never increase confidence solely by chaining assertions."

  VALIDATION:
    - "Check endpoint types, referential integrity, guard evaluation and dependency direction."
    - "Detect unsatisfied prerequisites, deadlocks, circular dependencies and inconsistent status transitions."
    - "Validate resource availability, artefact versions, timing units and scheduling semantics."
    - "Preserve conflicting evidence for review instead of silently resolving it."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, dependency assertions, inference rules and provenance"
    note: "Compute at execution; no hash value is claimed here."

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, normalise, validate, detect_cycles, reconcile, recompute_dependencies, assess_impact, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed dependency graph with guarded edges and evidence-backed assertions"
    outputs: [dependency_edges, prerequisite_paths, execution_readiness, blocked_activities, impact_candidates, validation_reports, provenance_records]
    safeguards: [no_unverified_dependencies, no_automatic_causal_claims, distinguish_unknown_from_false, preserve_dependency_direction, flag_cycles]
}

END FLOW ALGEBRA