Service Relationship Ontology

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

flow "ServiceRelationshipOntology" v1.0 {
  ontology:
    id: "service-relationship-ontology"
    parent: "system-relationships"
    purpose: "Represent evidence-backed relationships among services, providers, consumers, interfaces, contracts, dependencies and execution outcomes."

  types:
    System: {id: string, name: string, version: string?}
    Service: {id: string, name: string, version: string, lifecycle: enum[proposed, active, deprecated, retired]}
    Actor: {id: string, kind: enum[person, organisation, software_agent, system]}
    Interface: {id: string, protocol: string?, schema: string?, version: string?}
    Contract: {id: string, version: string, preconditions: string[], postconditions: string[], obligations: string[]}
    Operation: {id: string, service_id: string, input_schema: string?, output_schema: string?}
    Execution: {id: string, operation_id: string, timestamp: datetime, status: enum[pending, running, succeeded, failed, cancelled], provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    provides(provider: Actor, service: Service)
    consumes(consumer: Actor, service: Service)
    exposes(service: Service, interface: Interface)
    governed_by(service: Service, contract: Contract)
    offers(service: Service, operation: Operation)
    depends_on(service_a: Service, service_b: Service)
    composes(service_a: Service, service_b: Service)
    hosted_by(service: Service, system: System)
    invokes(execution: Execution, operation: Operation)
    fulfils(execution: Execution, contract: Contract)

  constraints:
    - "All relationship endpoints must resolve to typed, versioned entities where applicable."
    - "Confidence values must lie within [0,1]."
    - "A service provider is not necessarily its owner, host or operator."
    - "A dependency does not imply service availability, successful execution or transitive contractual obligations."
    - "Contract fulfilment requires evaluated preconditions, postconditions and relevant evidence."
    - "Cycles in service dependencies must be detected and evaluated, not automatically rejected."
    - "Interface compatibility must consider protocol, schema, version and operational context."
    - "Do not infer successful execution from invocation alone."

  inference:
    rule provider_service_link:
      if provides(a,s) and valid(a) and valid(s)
      then service_provider_record(s,a)
      confidence: "evidence dependent"
    rule dependency_impact:
      if depends_on(a,b) and unavailable(b) and requires_runtime_access(a,b)
      then potential_impact(a,b)
      confidence: "context and redundancy dependent"
    rule operation_exposure:
      if offers(s,o) and exposes(s,i) and binds(o,i)
      then operation_accessible_via(o,i)
      confidence: "subject to interface and access validation"
    rule execution_evidence:
      if invokes(e,o) and execution_status(e,"succeeded") and verified_postconditions(e)
      then verified_success(e,o)
      confidence: "retain original execution evidence"

  SEMANTIC_EQUIVALENCE:
    - "Map service aliases to canonical, version-aware identifiers."
    - "Distinguish equivalent service capabilities from identical service instances."
    - "Do not merge services solely because their names or interfaces match."
    - "Preserve provider, deployment, contract and temporal context."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, interface_validation, contract_evidence, execution_observation, temporal_validity, independent_confirmation]
    policy: "Preserve uncertainty; do not increase confidence solely through inference chaining."

  VALIDATION:
    - "Check endpoint types, service and contract versions, and referenced identifiers."
    - "Validate interface bindings and input/output schemas."
    - "Check dependency cycles, lifecycle status and stale service declarations."
    - "Distinguish observed outcomes from expected outcomes and inferred capabilities."
    - "Retain provenance for each assertion and derived relationship."

  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, version-aware service relationship graph"
    outputs: [service_links, provider_consumer_edges, interface_contract_links, dependency_graphs, execution_evidence, uncertainty_annotations, provenance_records]
    safeguards: [no_unverified_service_claims, no_automatic_identity_merges, preserve_versions_and_contracts, flag_unverified_dependencies]
}

END FLOW ALGEBRA