Node Relationship Ontology

FLOW ALGEBRA
Node Relationship Ontology
Version: 1.0
Source: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/structural-relationships/node-relationship-ontology.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Status: Companion formalisation; source page not independently verified.

FLOW "NodeRelationshipOntology" v1.0

ENTITY_TYPES:
  Node: {id: URI, label: String, node_type: String, properties: Map, valid_from: DateTime?, valid_to: DateTime?}
  Edge: {id: URI, source: Node.id, target: Node.id, predicate: URI, directed: Boolean, weight: Number?, evidence: Evidence.id?}
  Graph: {id: URI, nodes: Set<Node>, edges: Set<Edge>}
  Evidence: {id: URI, source: URI, recorded_at: DateTime, reliability: Number[0..1]}

RELATIONSHIPS:
  CONNECTED_TO(a: Node, b: Node) := EXISTS e: Edge WHERE e.source=a.id AND e.target=b.id
  ADJACENT_TO(a: Node, b: Node) := CONNECTED_TO(a,b) OR CONNECTED_TO(b,a)
  HAS_INCOMING_EDGE(n: Node, e: Edge) := e.target=n.id
  HAS_OUTGOING_EDGE(n: Node, e: Edge) := e.source=n.id
  MEMBER_OF(n: Node, g: Graph) := n IN g.nodes
  REACHABLE_FROM(a: Node, b: Node) := EXISTS finite path a -> b

CONSTRAINTS:
  - Node.id MUST be unique within the graph.
  - Edge endpoints MUST resolve to graph members.
  - Edge.id MUST be unique within the graph.
  - Node identity MUST NOT be inferred solely from a shared label.
  - Directed edges MUST NOT be treated as symmetric unless predicate semantics allow it.
  - Self-loops and parallel edges MAY exist if permitted by the graph schema.
  - Reachability MUST NOT imply a direct edge.

INFERENCE:
  rule adjacency: CONNECTED_TO(a,b) => ADJACENT_TO(a,b)
  rule incident_source: Edge(e,a,b) => HAS_OUTGOING_EDGE(a,e)
  rule incident_target: Edge(e,a,b) => HAS_INCOMING_EDGE(b,e)
  rule reachability_base: CONNECTED_TO(a,b) => REACHABLE_FROM(a,b)
  rule reachability_step: REACHABLE_FROM(a,b) AND CONNECTED_TO(b,c) => REACHABLE_FROM(a,c)
  note: Reachability closure MUST be cycle-safe and preserve directedness.

SEMANTIC_EQUIVALENCE:
  - Equivalent node identifiers require an explicit identity mapping or verified equivalence evidence.
  - sameAs MUST NOT be substituted for relatedTo, adjacentTo or similarTo.
  - Predicate equivalence requires matching domain, range and directionality.

CONFIDENCE:
  input: Evidence.reliability in [0,1]
  output: relationship_confidence in [0,1]
  policy: Use calibrated aggregation; retain evidence dependencies and uncertainty.
  rule: Inferred confidence MUST NOT exceed what supporting evidence justifies.

VALIDATION:
  - verify_unique_node_ids
  - verify_edge_endpoint_integrity
  - verify_predicate_domain_and_range
  - verify_temporal_consistency
  - verify_evidence_traceability
  - verify_inference_cycle_safety

FLOW_HASH:
  algorithm: SHA-256
  input: canonical_serialisation(entity_types, relationships, constraints, inference, semantic_equivalence, validation)
  output: lowercase_hex_digest
  note: Compute digest from actual canonical bytes during implementation; no placeholder digest is asserted.

UPDATE_MODEL:
  strategy: versioned_incremental_update
  operations: [add_node, update_node, remove_node, add_edge, update_edge, remove_edge]
  on_change: [validate_integrity, recompute_affected_inferences, update_provenance, regenerate_flow_hash]
  deletion_policy: remove_or_reconcile_incident_edges_before_node_deletion

AI_CONSUMPTION:
  format: typed_graph
  capabilities: [entity_resolution, graph_navigation, neighbourhood_query, path_query, relationship_inference, provenance_inspection]
  safeguards: [preserve_directionality, distinguish_asserted_from_inferred, respect_confidence, retain_source_attribution]

END FLOW