Workflow Relationship Ontology

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

flow "WorkflowRelationshipOntology" v1.0 {
  ontology:
    id: "workflow-relationship-ontology"
    parent: "process-relationships"
    purpose: "Represent typed dependencies, control flow, resource assignments and evidence-backed transitions between workflow activities."

  types:
    Workflow: {id: string, version: string, status: enum[draft, active, paused, completed, cancelled]}
    Activity: {id: string, workflow_id: string, kind: string, status: enum[pending, ready, running, completed, failed, skipped]}
    Actor: {id: string, role: string}
    Resource: {id: string, kind: string, capacity: number?}
    Artifact: {id: string, media_type: string?, version: string?}
    Condition: {id: string, expression: string, evaluation_context: string}
    Transition: {id: string, from_activity: string, to_activity: string, guard: string?, kind: enum[sequence, branch, join, retry, compensation]}
    Evidence: {id: string, source: string, timestamp: datetime?, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    belongs_to(activity: Activity, workflow: Workflow)
    precedes(a: Activity, b: Activity)
    depends_on(a: Activity, prerequisite: Activity)
    transitions_to(a: Activity, b: Activity)
    performed_by(activity: Activity, actor: Actor)
    uses(activity: Activity, resource: Resource)
    consumes(activity: Activity, artifact: Artifact)
    produces(activity: Activity, artifact: Artifact)
    guarded_by(transition: Transition, condition: Condition)
    compensates(activity: Activity, prior_activity: Activity)

  constraints:
    - "Every workflow activity and transition must resolve to an existing typed entity."
    - "Transition endpoints must belong to the same workflow unless an explicit cross-workflow interface is declared."
    - "Confidence values must lie within [0, 1]."
    - "A dependency must not be interpreted as evidence of causation without supporting evidence."
    - "Cycles are allowed only where explicitly modelled as loops, retries or compensating flows with termination safeguards."
    - "Parallel branches and synchronisation joins must specify their execution semantics."
    - "A completed activity requires an auditable completion event; an asserted transition does not prove execution."
    - "Resource assignments must respect declared capacity and authorisation constraints."
    - "Workflow versions must preserve the identity of historical executions."

  inference:
    rule dependency_from_sequence:
      if precedes(a,b) and sequence_requires_completion(a,b)
      then depends_on(b,a)
      confidence: "inherit supporting evidence; do not assert for unconstrained ordering"
    rule indirect_dependency:
      if depends_on(a,b) and depends_on(b,c) and compatible_workflow_context(a,b,c)
      then indirectly_depends_on(a,c)
      confidence: "propagate provenance and uncertainty"
    rule eligible_transition:
      if completed(a) and transitions_to(a,b) and guard_satisfied(a,b) and prerequisites_satisfied(b)
      then eligible_to_start(b)
      confidence: "eligibility only; does not imply actual execution"
    rule blocked_activity:
      if depends_on(a,b) and not_completed(b)
      then blocked_by(a,b)
      confidence: "subject to version and runtime state"

  SEMANTIC_EQUIVALENCE:
    - "Normalise activity, task, step and operation terms only within compatible workflow contexts."
    - "Distinguish sequencing, dependency, causation, assignment and execution."
    - "Preserve workflow version, guard semantics and actor roles when aligning models."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, execution_logs, model_completeness, temporal_validity, independent_verification]
    policy: "Do not increase confidence solely through multi-hop inference."

  VALIDATION:
    - "Check typed endpoints, valid transitions, workflow membership and referential integrity."
    - "Detect unintended cycles, unreachable activities, deadlocks and unsatisfied joins."
    - "Validate guards, resource availability, permissions and termination conditions."
    - "Keep inferred workflow paths separate from observed execution traces."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, workflow definitions, typed relationships, rules and provenance"
    note: "Compute hash at execution; no hash value is claimed here."

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

  AI_CONSUMPTION:
    representation: "typed workflow graph with evidence-backed transitions and execution state"
    outputs: [workflow_nodes, relationship_edges, dependency_paths, transition_guards, execution_traces, uncertainty_annotations, provenance_records]
    safeguards: [no_invented_execution_events, no_unsupported_causation, preserve_workflow_versions, require_guard_validation]
}

END FLOW ALGEBRA