Identity Relationship Ontology

FLOW ALGEBRA
Identity Relationship Ontology — Semantic Relationships
Version: 1.0
Authors: Mark Anthony Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/semantic-relationships/identity-relationship-ontology.html
Status: Companion formalisation; embedded source specification not available in retrieved page text.

flow "IdentityRelationshipOntology" v1.0

DOMAIN:
  ontology: SemanticRelationships.IdentityRelationship
  purpose: Represent, resolve, validate and maintain identity assertions across entities, identifiers, records and contexts.

TYPES:
  Entity: {id: IRI, kind: String, attributes: Map}
  Identifier: {scheme: String, value: String, issuer: String?}
  Context: {domain: String, time: Interval?, jurisdiction: String?, scope: String?}
  Evidence: {source: IRI?, method: String, observed_at: DateTime?, reliability: Real[0,1]}
  IdentityAssertion: {left: Entity, right: Entity, relation: IdentityKind, context: Context, evidence: Set[Evidence], confidence: Real[0,1], status: AssertionStatus}
  IdentityKind: [same_as, distinct_from, possible_match, record_of, alias_of, identifier_of]
  AssertionStatus: [proposed, verified, disputed, rejected, superseded]

RELATIONSHIPS:
  SAME_AS(a: Entity, b: Entity, c: Context) -> Boolean
  DISTINCT_FROM(a: Entity, b: Entity, c: Context) -> Boolean
  POSSIBLE_MATCH(a: Entity, b: Entity, c: Context) -> Real[0,1]
  ALIAS_OF(label: String, entity: Entity, c: Context) -> Boolean
  IDENTIFIER_OF(identifier: Identifier, entity: Entity, c: Context) -> Boolean
  RECORD_OF(record: Entity, referent: Entity, c: Context) -> Boolean

AXIOMS:
  A1: SAME_AS(a,a,c) = true.
  A2: SAME_AS(a,b,c) => SAME_AS(b,a,c).
  A3: SAME_AS(a,b,c) AND SAME_AS(b,d,c) => SAME_AS(a,d,c), only if identity scope and referent semantics are compatible.
  A4: DISTINCT_FROM(a,b,c) => DISTINCT_FROM(b,a,c).
  A5: DISTINCT_FROM(a,a,c) = false.
  A6: SAME_AS(a,b,c) AND DISTINCT_FROM(a,b,c) => CONFLICT(a,b,c).
  A7: POSSIBLE_MATCH(a,b,c) does not entail SAME_AS(a,b,c).
  A8: ALIAS_OF(label,a,c) does not entail identity between all entities sharing label.
  A9: Matching identifier values imply identity only when the identifier scheme is unique, authoritative and applicable in c.
  A10: RECORD_OF(record,referent,c) does not entail SAME_AS(record,referent,c).

INFERENCE:
  rule "verified-identifier":
    when unique_scheme(i.scheme,c) AND authoritative(i) AND IDENTIFIER_OF(i,a,c) AND IDENTIFIER_OF(i,b,c)
    then propose SAME_AS(a,b,c) with evidence and conflict checks.
  rule "contextual-same-as":
    when SAME_AS(a,b,c) AND compatible(c,c2) AND persistence_verified(a,b,c2)
    then propose SAME_AS(a,b,c2).
  rule "identity-conflict":
    when SAME_AS(a,b,c) AND DISTINCT_FROM(a,b,c)
    then status = disputed; block automatic merge.
  rule "alias-resolution":
    when ALIAS_OF(label,a,c) AND observed_label(record,label,c)
    then candidate(record,a); require independent corroboration.

SEMANTIC_EQUIVALENCE:
  exact_identity: SAME_AS only with validated shared referent.
  lexical_equivalence: equal names or labels are not sufficient for identity.
  contextual_equivalence: interchangeable in a specified task does not imply global identity.
  identity_vs_similarity: similarity and relatedness must remain distinct from identity.
  external_mapping: owl:sameAs is strong identity; skos:exactMatch and closeMatch are mapping relations, not unrestricted entity identity.

CONFIDENCE:
  range: [0,1]
  inputs: [identifier_authority, provenance_quality, attribute_agreement, temporal_consistency, contradiction_penalty]
  rule: confidence is evidence-weighted and calibrated; never use a fixed score as proof of identity.
  threshold_policy: configured_per_domain; low-confidence links remain candidates.
  propagation: inference confidence must not exceed justified supporting evidence.

VALIDATION:
  - Require resolvable entity identifiers and valid relation type.
  - Verify scope, time and jurisdiction before cross-context identity propagation.
  - Detect contradictions, duplicate assertions and circular evidence dependencies.
  - Prevent automatic merging on names, aliases or similarity alone.
  - Retain evidence, provenance, revision history and disputed assertions.
  - Check privacy and data-minimisation requirements for person identity resolution.

FLOW_HASH:
  algorithm: SHA-256
  canonical_input: [ontology_version, canonical_entities, relation, context, evidence_ids, assertion_status]
  output: stable_content_digest
  note: compute digest over deterministic UTF-8 serialisation; exclude volatile timestamps unless part of the assertion.

UPDATE_MODEL:
  operations: [create_assertion, verify, dispute, reject, supersede, split_identity, merge_identity]
  preconditions: [authorised_actor, evidence_present, consistency_check]
  on_update: [revalidate_dependent_inferences, recompute_flow_hash, preserve_audit_trail]
  merge_policy: never destructively merge original records; maintain reversible identity links.

AI_CONSUMPTION:
  representation: typed assertions with context, evidence and status
  retrieval: expose verified identities separately from candidate matches
  reasoning: apply axioms only inside compatible scopes
  output: [resolved_entity, identity_relation, confidence, provenance, conflicts, flow_hash]
  safety: abstain from definitive identity claims when evidence is insufficient or conflicting.

END FLOW ALGEBRA