Process Relationships

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

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

flow "ProcessRelationships" v1.0 {
  ontology:
    id: "process-relationships"
    parent: "relationship-ontologies"
    purpose: "Represent process steps, dependencies, transitions, actors, inputs, outputs and evidence-backed execution relationships."

  types:
    Process: {id: string, name: string, version: string, status: enum[draft, active, suspended, completed, retired]}
    Activity: {id: string, process_id: string, name: string, status: enum[pending, ready, running, completed, failed, skipped]}
    Actor: {id: string, role: string}
    Resource: {id: string, kind: string}
    Artifact: {id: string, kind: string, version: string?}
    Transition: {id: string, source: string, target: string, guard: string?, effect: string?}
    Observation: {id: string, timestamp: datetime, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    contains(process: Process, activity: Activity)
    precedes(a: Activity, b: Activity)
    depends_on(a: Activity, prerequisite: Activity)
    transitions_to(a: Activity, b: Activity)
    performed_by(activity: Activity, actor: Actor)
    consumes(activity: Activity, artifact: Artifact)
    produces(activity: Activity, artifact: Artifact)
    uses(activity: Activity, resource: Resource)
    enables(a: Activity, b: Activity)
    observed_in(activity: Activity, observation: Observation)

  constraints:
    - "All relationship endpoints must resolve to typed entities."
    - "Confidence must lie within [0, 1]."
    - "Each activity belongs to a declared process or explicitly references a cross-process scope."
    - "Dependencies and temporal precedence are distinct from causation."
    - "Transition guards must be evaluated before execution; no transition is presumed merely from adjacency."
    - "Cycles in dependency graphs must be flagged unless iterative semantics and termination controls are defined."
    - "Execution events must preserve timestamps, source identity and provenance."
    - "A completed activity does not establish successful downstream outcomes without evidence."

  inference:
    rule dependency_chain:
      if depends_on(a,b) and depends_on(b,c) and compatible_scope(a,b,c)
      then indirectly_depends_on(a,c)
      confidence: "retain supporting paths and avoid unsupported certainty"
    rule predecessor_chain:
      if precedes(a,b) and precedes(b,c) and same_execution_context(a,b,c)
      then precedes(a,c)
      confidence: "propagate temporal evidence"
    rule guarded_transition:
      if transitions_to(a,b) and completed(a) and guard_satisfied(a,b)
      then eligible_to_start(b)
      confidence: "guard and execution evidence dependent"
    rule artifact_lineage:
      if produces(a,x) and consumes(b,x)
      then information_dependency(b,a,x)
      confidence: "retain artifact identity and version"

  SEMANTIC_EQUIVALENCE:
    - "Normalise process and activity labels using versioned controlled vocabularies."
    - "Distinguish identical activity, similar activity, successor activity and process role."
    - "Preserve execution context, actor, scope and version during alignment."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, execution_evidence, temporal_consistency, rule_validity, independent_confirmation]
    policy: "Do not increase confidence solely by chaining inferred relationships."

  VALIDATION:
    - "Check entity types, process membership, guards, dependencies and provenance."
    - "Detect impossible state transitions, missing prerequisites and unsupported cycles."
    - "Check artifact versions and resource availability where required."
    - "Retain competing process interpretations when evidence is inconclusive."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed assertions, 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 process knowledge graph with evidence-backed relations"
    outputs: [process_graphs, dependency_paths, transition_candidates, lineage_records, uncertainty_annotations, provenance_records]
    safeguards: [no_unsupported_causal_claims, enforce_transition_guards, detect_cycles, preserve_versions_and_evidence]
}

END FLOW ALGEBRA