Relationship Taxonomy Ontology

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

PURPOSE
Classify, type, validate and reason over relationships between entities in a semantic knowledge system. This specification is a companion model, not a verbatim transcription of the source page.

ENTITY TYPES
Entity := {id: URI, type: Class, labels: Set[String], attributes: Map}
RelationshipType := {id: URI, label: String, domain: Class, range: Class, parent?: RelationshipType, properties: Set[Property]}
RelationshipAssertion := {subject: Entity, predicate: RelationshipType, object: Entity, provenance?: Source, confidence: Float, valid_time?: Interval}
Taxonomy := {types: Set[RelationshipType], subTypeOf: PartialOrder}

RELATIONSHIP TAXONOMY
1. Structural: partOf, hasPart, contains, memberOf, connectedTo.
2. Hierarchical: subClassOf, instanceOf, broaderThan, narrowerThan.
3. Associative: relatedTo, similarTo, correspondsTo, collaboratesWith.
4. Causal: causes, influences, enables, prevents.
5. Temporal: precedes, follows, overlaps, occursDuring.
6. Spatial: locatedIn, adjacentTo, intersects, disjointFrom.
7. Functional: performs, uses, produces, dependsOn.
8. Logical: entails, contradicts, equivalentTo, implies.
9. Social/organisational: manages, reportsTo, owns, participatesIn.
10. Semantic: synonymOf, mapsTo, semanticallyEquivalentTo.

FLOW OPERATORS
DECLARE_TYPE(name, domain, range, parent?, properties?) -> RelationshipType
ASSERT(subject, predicate, object, provenance?, confidence?) -> RelationshipAssertion
CLASSIFY(assertion) -> Set[RelationshipType]
VALIDATE(assertion, taxonomy) -> ValidationResult
INFER(graph, rules) -> Set[RelationshipAssertion]
TRAVERSE(entity, predicate, direction, depth) -> Set[Entity]
NORMALISE(predicate, taxonomy) -> CanonicalRelationshipType

FORMAL CONSTRAINTS
For every assertion (s,p,o): type(s) <= domain(p) AND type(o) <= range(p).
subTypeOf is reflexive, antisymmetric and transitive on canonical relationship types.
If p subTypeOf q, then (s,p,o) entails (s,q,o), subject to valid domain/range constraints.
If p is symmetric: (a,p,b) => (b,p,a).
If p is transitive: (a,p,b) AND (b,p,c) => (a,p,c).
If inverseOf(p,q): (a,p,b) => (b,q,a).
If p is irreflexive: NOT (a,p,a).
Do not infer symmetry, transitivity or inverses without declared axioms.

CONFIDENCE
CONFIDENCE(assertion) := value in [0,1] with provenance and calibration context.
Derived assertions retain source links and rule identifiers; inference confidence must follow an explicitly declared combination policy.

SEMANTIC_EQUIVALENCE
SEMANTIC_EQUIVALENCE(p,q) := equivalent meaning under declared context, compatible domains/ranges, and validated mappings.
Equivalence must not be inferred solely from similar labels.

FLOW_HASH
FLOW_HASH := SHA256(canonical_serialisation(taxonomy_version, type_definitions, axioms, mappings, assertions, provenance)).
Canonicalisation sorts identifiers and normalises datatype representations before hashing.

UPDATE_MODEL
UPDATE_MODEL(change): validate schema -> check affected constraints -> update type hierarchy and mappings -> recompute affected inferences -> record version and provenance -> recompute FLOW_HASH.
Reject or quarantine conflicting assertions rather than silently overwriting them.

AI_CONSUMPTION
Input: typed graph, taxonomy version, axioms, confidence, provenance.
Output: classified relationship assertions, explanation paths, validation findings, and uncertainty indicators.
AI agents must distinguish asserted facts from inferred claims and avoid promoting unverified mappings to equivalence.

EXAMPLE
DECLARE_TYPE("partOf", Component, Assembly, properties={transitive})
ASSERT(engine, partOf, vehicle, source_record, 0.98)
VALIDATE(assertion, taxonomy)
CLASSIFY(assertion) -> {Structural, partOf}

END FLOW ALGEBRA