Process Relationship Ontology

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

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

  types:
    Process: {id: string, name: string, version: string?, status: string?}
    Activity: {id: string, process_id: string, name: string, state: string?}
    Actor: {id: string, role: string}
    Resource: {id: string, kind: string}
    State: {id: string, label: string, observed_at: datetime?}
    Outcome: {id: string, description: string, observed: boolean?}
    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:
    contains(process: Process, activity: Activity)
    precedes(a: Activity, b: Activity)
    depends_on(a: Activity, b: Activity)
    performed_by(activity: Activity, actor: Actor)
    consumes(activity: Activity, resource: Resource)
    produces(activity: Activity, resource: Resource)
    transitions_from(activity: Activity, state: State)
    transitions_to(activity: Activity, state: State)
    contributes_to(activity: Activity, outcome: Outcome)
    related_to(a: Process, b: Process)

  constraints:
    - "Every relationship endpoint must resolve to an entity of the declared type."
    - "Confidence must lie within [0, 1]."
    - "Activity membership must reference an existing process."
    - "Temporal precedence must not be interpreted as causation without supporting evidence."
    - "Dependencies must distinguish mandatory prerequisites from optional associations."
    - "Precedence cycles are invalid in strict acyclic execution models; iterative workflows must explicitly declare loops."
    - "Do not infer that a process succeeded merely because an activity was performed."
    - "Preserve process versions, execution context and evidence provenance."

  inference:
    rule precedence_transitivity:
      if precedes(a,b) and precedes(b,c) and compatible_execution_context(a,b,c)
      then precedes(a,c)
      confidence: "derived from source assertions without artificial confidence inflation"
    rule process_membership:
      if contains(p,a) and performed_by(a,x)
      then participates_in(x,p)
      confidence: "retain activity-level evidence; do not imply responsibility for the entire process"
    rule resource_lineage:
      if produces(a,r) and consumes(b,r) and same_resource_version(a,b,r)
      then resource_flows_between(a,b,r)
      confidence: "require verified resource identity and execution context"

  SEMANTIC_EQUIVALENCE:
    - "Distinguish process identity, process type, activity similarity and shared outcomes."
    - "Map synonyms through versioned vocabularies with domain-specific context."
    - "Do not merge processes solely because they have matching names or outputs."

  CONFIDENCE:
    range: [0,1]
    factors: [evidence_quality, source_reliability, execution_trace_completeness, temporal_consistency, independent_verification]
    policy: "Propagate uncertainty and preserve evidence dependencies."

  VALIDATION:
    - "Validate entity references, types, predicates and process membership."
    - "Check temporal order, loop declarations, dependency cycles and resource versions."
    - "Flag contradictory execution states and unsupported causal conclusions."
    - "Preserve competing interpretations when evidence is incomplete."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed 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, compare, reconcile, recompute_inferences, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed process knowledge graph with evidence-backed relationships"
    outputs: [process_links, activity_dependencies, resource_lineage, state_transitions, inferred_relationships, provenance_records]
    safeguards: [no_unsupported_causal_claims, no_unverified_process_merges, preserve_versions_and_context]
}

END FLOW ALGEBRA