Execution Relationship Ontology

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

flow "ExecutionRelationshipOntology" v1.0 {
  ontology:
    id: "execution-relationship-ontology"
    parent: "process-relationships"
    purpose: "Represent evidence-backed execution relationships among processes, tasks, actors, resources, states and outcomes."

  types:
    Process: {id: string, version: string, definition: string}
    Activity: {id: string, process_id: string, preconditions: string[], postconditions: string[]}
    Execution: {id: string, activity_id: string, started_at: datetime?, ended_at: datetime?, status: enum[pending, running, succeeded, failed, cancelled, unknown]}
    Actor: {id: string, kind: enum[human, software, machine, organisation, other]}
    Resource: {id: string, kind: string, capacity: number?}
    State: {id: string, label: string, observed_at: datetime?}
    Output: {id: string, kind: string, provenance: string}
    Evidence: {id: string, source: string, timestamp: datetime?, reliability: number?}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    executes(actor: Actor, execution: Execution)
    instantiates(execution: Execution, activity: Activity)
    part_of(activity: Activity, process: Process)
    depends_on(activity: Activity, prerequisite: Activity)
    uses(execution: Execution, resource: Resource)
    transitions_from(execution: Execution, state: State)
    transitions_to(execution: Execution, state: State)
    produces(execution: Execution, output: Output)
    precedes(first: Execution, second: Execution)
    observed_by(execution: Execution, evidence: Evidence)

  constraints:
    - "Every execution must resolve to a defined activity and retain its process version."
    - "Confidence must lie within [0, 1]."
    - "Execution identifiers must be unique within their declared scope."
    - "A completed execution must have a coherent start and end timestamp when both are known."
    - "Do not equate a scheduled activity with a confirmed execution."
    - "Do not infer success from initiation, resource allocation or lack of failure reports."
    - "A dependency does not necessarily imply chronological ordering without explicit workflow semantics."
    - "Parallel executions must not be forced into an unsupported total order."
    - "Evidence and provenance must be retained for asserted outcomes."

  inference:
    rule execution_membership:
      if instantiates(e,a) and part_of(a,p)
      then execution_of_process(e,p)
      confidence: "inherit supporting evidence without artificial amplification"
    rule completed_transition:
      if transitions_to(e,s) and verified_terminal_state(s,"succeeded")
      then candidate_status(e,"succeeded")
      confidence: "requires authoritative completion evidence"
    rule temporal_precedence:
      if precedes(a,b) and precedes(b,c) and compatible_clock_context(a,b,c)
      then precedes(a,c)
      confidence: "propagate temporal uncertainty and provenance"
    rule dependency_readiness:
      if depends_on(a,b) and verified_completion(b) and all_other_preconditions_met(a)
      then eligible_to_execute(a)
      confidence: "eligibility is not evidence of actual execution"

  SEMANTIC_EQUIVALENCE:
    - "Align process, task, run, job and execution terminology only within a declared context."
    - "Distinguish an activity definition from a particular execution instance."
    - "Do not merge execution records solely because they share names or timestamps."
    - "Preserve identifiers, versions, actor roles and temporal context."

  CONFIDENCE:
    range: [0,1]
    factors: [event_log_integrity, observation_reliability, timestamp_accuracy, source_independence, process_version_match]
    policy: "Do not increase confidence solely through chained inference or repeated evidence."

  VALIDATION:
    - "Check typed endpoints, referential integrity and permitted state transitions."
    - "Validate timestamps, timezone conventions and clock uncertainty."
    - "Detect contradictory outcomes, missing prerequisites and impossible execution cycles."
    - "Separate observed execution facts from predicted or inferred states."
    - "Retain unresolved conflicts and alternative explanations."

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

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

  AI_CONSUMPTION:
    representation: "typed execution and process knowledge graph with evidence-backed edges"
    outputs: [execution_triples, state_transitions, dependency_links, inferred_relations, confidence_annotations, provenance_records]
    safeguards: [no_unverified_completion_claims, preserve_execution_identity, respect_temporal_uncertainty, retain_evidence]
}

END FLOW ALGEBRA