Relationship Classification Ontology

FLOW ALGEBRA
RELATIONSHIP CLASSIFICATION ONTOLOGY
Version: 1.0
Source: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/foundations-of-relationships/relationship-classification-ontology.html
Authors: Mark Higgins — Sky (Recursive AI)

PURPOSE
Classify semantic relationships between entities by formal properties, meaning, context, direction, and evidence. This is a companion formalisation, not a transcription of the source page.

ENTITY TYPES
Entity := {id: IRI, type: Class, labels: Set[String], provenance: Source?}
RelationType := {id: IRI, domain: Class, range: Class, properties: Set[Property]}
Assertion := {subject: Entity, predicate: RelationType, object: Entity, context: Context, evidence: Set[Evidence]}
Context := {domain: IRI?, temporal_scope: Interval?, jurisdiction: IRI?, interpretation: String?}
Classification := {assertion: Assertion, categories: Set[Category], confidence: Real[0,1], justification: Set[RuleID]}

CLASSIFICATION AXES
semantic_function := {taxonomic, part_whole, causal, temporal, spatial, functional, associative, comparative, dependency, ownership, provenance}
logical_property := {reflexive, irreflexive, symmetric, asymmetric, antisymmetric, transitive, intransitive, functional, inverse_functional}
direction := {directed, bidirectional, undirected}
arity := {binary, n_ary_reified}
modality := {asserted, inferred, hypothetical, disputed}
evidence_status := {verified, supported, uncertain, unsupported}

TYPED RELATIONSHIPS
IS_A(x: Entity, y: Class) -> taxonomic
PART_OF(x: Entity, y: Entity) -> part_whole
CAUSES(x: Event, y: Event) -> causal
PRECEDES(x: Event, y: Event) -> temporal
LOCATED_IN(x: Entity, y: Place) -> spatial
DEPENDS_ON(x: Entity, y: Entity) -> dependency
RELATED_TO(x: Entity, y: Entity) -> associative

FLOW RULES
R01 TYPE_CHECK: valid(a) iff type(a.subject) <= domain(a.predicate) AND type(a.object) <= range(a.predicate).
R02 TAXONOMY: predicate(a)=IS_A => category(a)=taxonomic.
R03 PARTONOMY: predicate(a)=PART_OF => category(a)=part_whole.
R04 CAUSALITY: predicate(a)=CAUSES => category(a)=causal; causal claims require appropriate evidence.
R05 SYMMETRY: symmetric(r) AND r(x,y) => r(y,x).
R06 INVERSE: inverse(r,s) AND r(x,y) => s(y,x).
R07 TRANSITIVITY: transitive(r) AND r(x,y) AND r(y,z) => r(x,z), subject to context compatibility.
R08 ASYMMETRY: asymmetric(r) AND r(x,y) => NOT r(y,x).
R09 CONFLICT: incompatible categories or contradictory properties => flag for review; do not silently discard assertions.
R10 CONTEXT: classification is scoped to the asserted interpretation and temporal/domain context.
R11 PROVENANCE: inferred classifications retain source assertions and rule identifiers.
R12 N_ARY: relations with more than two participants use an explicit relation-instance entity with participant roles.

SEMANTIC_EQUIVALENCE
Equivalent(r1,r2) iff compatible(domain,range,meaning,context,logical_properties) AND supported_by_mapping_evidence.
Equivalent labels alone do not establish equivalence.
BroaderThan(r1,r2) and NarrowerThan(r1,r2) are mappings, not identity.

CONFIDENCE
confidence(a) := calibrated_support(evidence(a), source_quality, agreement, context_fit).
confidence(inference) <= min(confidence(premises)) unless a separately validated calibration model justifies otherwise.
Confidence is not truth and does not replace logical validation.

VALIDATION
CHECK unique identifiers, resolvable types, permitted domain/range, coherent inverse mappings, satisfiable property constraints, provenance presence, context compatibility, and absence of unresolved contradictions.
RETURN {status: valid|review|invalid, violations: Set[Violation], explanations: Set[String]}.

FLOW_HASH
canonical_payload := normalise({ontology_version, assertion, categories, context, rules, provenance_ids});
FLOW_HASH := SHA256(UTF8(canonical_serialisation(canonical_payload))).
Hash excludes mutable processing timestamps; changed semantic content produces a new hash.

UPDATE_MODEL
ON source_or_schema_change:
  ingest -> normalise -> type_check -> classify -> infer -> detect_conflicts -> validate -> recalculate_confidence -> regenerate_FLOW_HASH -> publish_version.
Preserve prior versions and provenance; invalidate downstream inferences affected by changed premises.

AI_CONSUMPTION
input: {entities, relations, context, evidence, schema_version}
output: {classified_assertions, inferred_assertions, explanations, confidence, validation_report, flow_hash}
constraints: preserve provenance; distinguish asserted from inferred; avoid unsupported causal conclusions; expose ambiguity; respect domain-specific semantics.

EXAMPLE
assertion: PART_OF(engine, vehicle)
classification: {semantic_function: part_whole, direction: directed, modality: asserted}
validation: requires engine and vehicle to be valid entities with compatible types.

END FLOW ALGEBRA