Communication Relationship Ontology

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

flow "HumanCommunicationRelationshipOntology" v1.0 {
  ontology:
    id: "communication-relationship-ontology-2"
    parent: "human-relationships"
    purpose: "Represent evidence-backed communication relationships between people, groups and organisations, including messages, channels, intent, interpretation and feedback."

  types:
    Actor: {id: string, kind: enum[person, group, organisation], label: string?}
    Message: {id: string, content_ref: string?, language: string?, created_at: datetime?, sensitivity: string?}
    Channel: {id: string, mode: enum[spoken, written, signed, digital, visual, other], synchronous: bool?}
    CommunicationEvent: {id: string, sender: string, recipients: string[], message: string, channel: string, sent_at: datetime?, received_at: datetime?, context: string?, provenance: string}
    Interpretation: {id: string, event_id: string, interpreter: string, interpreted_meaning: string, confidence: number, evidence: string[]}
    Feedback: {id: string, responding_to: string, sender: string, message: string, timestamp: datetime?}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    sends(sender: Actor, event: CommunicationEvent)
    addressed_to(event: CommunicationEvent, recipient: Actor)
    uses_channel(event: CommunicationEvent, channel: Channel)
    conveys(event: CommunicationEvent, message: Message)
    receives(recipient: Actor, event: CommunicationEvent)
    interprets(actor: Actor, event: CommunicationEvent)
    responds_to(feedback: Feedback, event: CommunicationEvent)
    collaborates_with(a: Actor, b: Actor)

  constraints:
    - "All relationship endpoints must resolve to typed entities."
    - "Confidence must lie within [0, 1]."
    - "Sending does not prove delivery, reading, comprehension, agreement or consent."
    - "Addressed-to does not prove received-by."
    - "Do not infer mutual communication from a single directed message."
    - "Do not infer collaboration, trust or friendship from message frequency alone."
    - "Preserve temporal context, provenance, access controls and applicable privacy restrictions."
    - "Separate observed message content from inferred intention or interpretation."

  inference:
    rule documented_sender:
      if valid(event) and event.sender == actor.id
      then sends(actor,event)
      confidence: "bounded by event provenance"
    rule documented_recipient:
      if valid(event) and actor.id in event.recipients
      then addressed_to(event,actor)
      confidence: "do not infer actual receipt"
    rule feedback_link:
      if valid(feedback) and feedback.responding_to == event.id
      then responds_to(feedback,event)
      confidence: "requires resolvable reference and provenance"
    rule confirmed_exchange:
      if sends(a,event1) and receives(b,event1) and sends(b,event2) and receives(a,event2)
      then observed_bidirectional_exchange(a,b)
      confidence: "retain separate evidence for each direction"

  SEMANTIC_EQUIVALENCE:
    - "Normalise channel and communication-role terms using versioned vocabularies."
    - "Distinguish sender, author, forwarder, recipient and observer."
    - "Do not equate translation, paraphrase or interpretation with exact message identity."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, delivery_evidence, timestamp_quality, interpretation_ambiguity, contextual_completeness]
    policy: "Do not manufacture certainty or increase confidence solely by chaining inferences."

  VALIDATION:
    - "Validate actor, message, event and channel references."
    - "Check chronology, sender-recipient roles, provenance and permitted access."
    - "Flag contradictory delivery states and unsupported inferred intentions."
    - "Retain alternative interpretations when meaning is ambiguous."

  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, privacy-aware communication relationship graph"
    outputs: [communication_events, directed_relationships, feedback_links, interpretation_annotations, confidence_scores, provenance_records]
    safeguards: [no_unverified_intent_claims, no_assumed_consent, protect_sensitive_communications, preserve_evidence]
}

END FLOW ALGEBRA