Semantic Equivalence Ontology

FLOW ALGEBRA
TITLE: Semantic Equivalence Ontology
DOMAIN: Kireth Semantic Library / Relationship Ontologies / Semantic Relationships
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/semantic-relationships/semantic-equivalence-ontology.html
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
VERSION: 1.0
STATUS: Companion formalisation; not a transcription of hidden page code.

PURPOSE
Define testable, context-scoped semantic equivalence between concepts, expressions and entities without conflating similarity, identity or mere lexical overlap.

TYPES
  Entity(id: URI, kind: Symbol, labels: Set[String])
  Concept(id: URI, definition: String, domain: URI)
  Expression(id: URI, language: String, text: String)
  Context(id: URI, domain: URI, task: String, language: String?, time: Interval?)
  Evidence(id: URI, source: URI, method: Symbol, observed_at: DateTime)
  EquivalenceClaim(left: URI, right: URI, context: URI, evidence: Set[URI], confidence: Real[0,1], status: Symbol)
  Mapping(source: URI, target: URI, mapping_kind: Symbol, context: URI)

RELATIONS
  DENOTES(Expression, Concept, Context)
  EQUIVALENT_IN(Concept|Expression|Entity, Concept|Expression|Entity, Context)
  SIMILAR_TO(Entity, Entity, Context, score: Real[0,1])
  BROADER_THAN(Concept, Concept, Context)
  NARROWER_THAN(Concept, Concept, Context)
  CONTRADICTS(Concept, Concept, Context)
  SUPPORTED_BY(EquivalenceClaim, Evidence)
  MAPS_TO(Entity, Entity, Context)

SEMANTIC_EQUIVALENCE
  eq_c(a,b) := EQUIVALENT_IN(a,b,c)
  Reflexivity: admissible(a,c) => eq_c(a,a)
  Symmetry: eq_c(a,b) => eq_c(b,a)
  Transitivity: eq_c(a,b) AND eq_c(b,d) AND compatible_scope(c) => candidate(eq_c(a,d))
  IMPORTANT: Transitive closure is accepted only for verified equivalence claims under the same compatible context; uncertain candidates require revalidation.
  Context separation: eq_c1(a,b) does not imply eq_c2(a,b).
  Identity separation: eq_c(a,b) does not imply a.id = b.id.
  Similarity separation: SIMILAR_TO(a,b,c,s) does not imply eq_c(a,b).

INFERENCE
  R1: DENOTES(x,k,c) AND DENOTES(y,k,c) => candidate(EQUIVALENT_IN(x,y,c))
  R2: verified_bidirectional_entailment(a,b,c) => candidate(EQUIVALENT_IN(a,b,c))
  R3: CONTRADICTS(a,b,c) => reject(EQUIVALENT_IN(a,b,c))
  R4: BROADER_THAN(a,b,c) XOR NARROWER_THAN(a,b,c) => do_not_infer_equivalence(a,b,c)
  R5: verified(EQUIVALENT_IN(a,b,c)) AND valid_mapping(a,t,c) => candidate(MAPS_TO(b,t,c))

CONFIDENCE
  confidence(claim) := calibrated_score(evidence_quality, semantic_entailment, context_fit, source_independence, contradiction_penalty)
  require 0 <= confidence(claim) <= 1
  confidence is an evidence assessment, not a probability guarantee.
  threshold_accept := policy(context).accept_threshold
  status := accepted IF confidence >= threshold_accept AND no_unresolved_contradiction ELSE review

VALIDATION
  V1: All relation endpoints resolve to typed identifiers.
  V2: Context identifier exists and is attached to every non-reflexive claim.
  V3: Accepted equivalence is symmetric within its context.
  V4: No accepted equivalence conflicts with a verified contradiction in the same context.
  V5: Cross-language equivalence checks sense and pragmatic usage, not string matching.
  V6: Provenance exists for each accepted nontrivial claim.
  V7: Re-evaluate equivalence after definitions, context or evidence change.

FLOW_HASH
  canonical := canonicalise(version, types, relations, rules, context, accepted_claims, evidence_ids)
  FLOW_HASH := SHA256(UTF8(canonical))
  note: Stable ordering and Unicode normalisation are required for deterministic hashes.

UPDATE_MODEL
  on change(definition | mapping | evidence | context | validation_policy):
    identify affected equivalence claims
    invalidate affected derived inferences
    recompute confidence and constraints
    preserve prior versions and provenance
    publish new FLOW_HASH

AI_CONSUMPTION
  input: entity_or_expression_pair, context, evidence
  output: {equivalent: boolean | unknown, confidence: Real[0,1], context: URI, justification: Evidence[], flow_hash: HexString}
  policy:
    distinguish verified equivalence from semantic similarity
    never promote uncertain equivalence to identity
    expose contextual limitations and contradictory evidence
    return unknown where evidence is insufficient

END FLOW ALGEBRA