Interface Relationship Ontology

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

flow "InterfaceRelationshipOntology" v1.0 {
  ontology:
    id: "interface-relationship-ontology"
    parent: "system-relationships"
    purpose: "Represent, validate and trace interfaces and interactions between system components."

  types:
    System: {id: string, name: string, version: string?}
    Component: {id: string, system_id: string, type: string, version: string?}
    Interface: {id: string, owner_id: string, kind: enum[api, physical, electrical, mechanical, data, human_machine, other], version: string?, specification: string?}
    Port: {id: string, interface_id: string, direction: enum[input, output, bidirectional], datatype: string?, unit: string?}
    Contract: {id: string, interface_id: string, preconditions: string[], postconditions: string[], constraints: string[]}
    Interaction: {id: string, source_interface: string, target_interface: string, protocol: string?, timestamp: datetime?, evidence: string[]}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    exposes(component: Component, interface: Interface)
    owns(component: Component, interface: Interface)
    has_port(interface: Interface, port: Port)
    connects_to(source: Interface, target: Interface)
    compatible_with(a: Interface, b: Interface)
    governed_by(interface: Interface, contract: Contract)
    exchanges_with(a: Component, b: Component)
    depends_on(component: Component, interface: Interface)

  constraints:
    - "All interface endpoints and owners must resolve to typed entities."
    - "Confidence values must lie within [0,1]."
    - "Compatibility requires checking protocol, versions, port direction, datatype, units and contract constraints where applicable."
    - "Connectivity does not imply compatibility, successful execution, trust or authorisation."
    - "Do not assume connects_to or depends_on is symmetric or transitive."
    - "Do not infer that all interfaces of a component are mutually compatible."
    - "Preserve interface versions and operating context for all assertions."

  inference:
    rule component_exchange:
      if exposes(a,ia) and exposes(b,ib) and connects_to(ia,ib) and verified_exchange(ia,ib)
      then exchanges_with(a,b)
      confidence: "derive from verified exchange evidence; preserve direction"
    rule interface_contract:
      if governed_by(i,c) and satisfies(i,c) and validated(c)
      then contract_compliant(i,c)
      confidence: "retain test scope and contract version"
    rule compatibility_candidate:
      if compatible_protocol(a,b) and compatible_types(a,b) and compatible_versions(a,b)
      then candidate_compatible(a,b)
      confidence: "candidate only until relevant constraints and tests pass"

  SEMANTIC_EQUIVALENCE:
    - "Normalise interface identifiers and terminology against versioned system specifications."
    - "Distinguish interface identity, functional similarity, interoperability and contract equivalence."
    - "Preserve direction, protocol, units, versions and deployment context."

  CONFIDENCE:
    range: [0,1]
    factors: [specification_quality, test_coverage, source_reliability, version_match, runtime_observation, independent_replication]
    policy: "Do not increase confidence solely by chaining inferences."

  VALIDATION:
    - "Validate entity references, interface ownership, endpoint direction and compatibility."
    - "Check contract preconditions, postconditions, constraints and version compatibility."
    - "Flag unresolved dependencies, ambiguous interfaces, missing evidence and conflicting specifications."
    - "Distinguish design-time compatibility from verified runtime operation."

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

  AI_CONSUMPTION:
    representation: "typed system-interface knowledge graph with evidence-backed edges"
    outputs: [interface_links, component_dependencies, compatibility_assessments, contract_checks, inferred_edges, provenance_records]
    safeguards: [no_unverified_interoperability_claims, preserve_versions_and_units, enforce_contract_boundaries, distinguish_design_from_runtime]
}

END FLOW ALGEBRA