Foundations of Relationships

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA

Ontology: Foundations of Relationships
Domain: AI Core > Ontologies > Relationship Ontologies
Canonical URL: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/foundations-of-relationships.html
Authors: Mark Anthony Higgins — Sky (Recursive AI)

flow "FoundationsOfRelationships" v1.0

# ---------- DOMAIN ----------
domain:
  class: OntologyDomain
  category: RelationshipOntologies
  subject: FoundationsOfRelationships
  purpose:
    - define foundational concepts for representing semantic relationships
    - preserve relationship identity, participants, predicate, direction, arity, cardinality, domain, range, context, validity, confidence, and provenance
    - support ontology modelling, knowledge graphs, semantic search, inference, recursive traversal, and Flow Algebra
    - distinguish relationships from entities, attributes, co-occurrence, similarity, correlation, causation, and equivalence
    - establish machine-readable principles for relationship reasoning

# ---------- CORE ----------
entity Relationship:
  type: SemanticStructure
  connects:
    - RelationshipParticipant
    - RelationshipParticipant
  may_include:
    - relationship_identifier
    - predicate
    - participants
    - direction
    - arity
    - cardinality
    - domain
    - range
    - context
    - confidence
    - validity
    - provenance

entity RelationshipIdentifier:
  type: PersistentIdentifier
  identifies: Relationship

entity RelationshipParticipant:
  type: SemanticResource
  may_be:
    - Entity
    - Concept
    - Event
    - State
    - Process
    - Resource
    - Relationship

relationships:
  Relationship -> IDENTIFIED_BY -> RelationshipIdentifier
  Relationship -> HAS_PARTICIPANT -> RelationshipParticipant
  Relationship -> HAS_PREDICATE -> RelationshipPredicate
  Relationship -> MAY_HAVE_CONTEXT -> RelationshipContext
  Relationship -> MAY_HAVE_CONFIDENCE -> RelationshipConfidence
  Relationship -> MAY_HAVE_PROVENANCE -> RelationshipProvenance

# ---------- RELATIONSHIP IDENTITY ----------
rule identity:
  relationship identity SHOULD remain distinct
  from participant and predicate identity

rule label:
  relationship label != relationship identity

rule endpoints:
  same participants != same relationship
  when predicate, direction, context, or validity differs

# ---------- PREDICATE ----------
entity RelationshipPredicate:
  type: SemanticPredicate
  may_include:
    - predicate_identifier
    - preferred_label
    - definition
    - domain
    - range
    - inverse
    - symmetry
    - transitivity
    - reflexivity
    - constraints

rule predicate:
  predicate defines semantic meaning
  of relationship between participants

rule predicate_label:
  lexical predicate label != complete predicate semantics

# ---------- BINARY RELATIONSHIP ----------
entity BinaryRelationship:
  subtype_of: Relationship
  arity: 2

structure BinaryRelationshipTriple:
  subject: RelationshipParticipant
  predicate: RelationshipPredicate
  object: RelationshipParticipant

rule binary:
  binary relationship MUST preserve subject, predicate, and object

# ---------- N-ARY RELATIONSHIP ----------
entity NaryRelationship:
  subtype_of: Relationship
  arity: >= 2
  may_include:
    - participants
    - participant_roles
    - relationship_context

rule nary:
  n-ary relationship SHOULD preserve participant roles

rule flattening:
  n-ary relationship MUST NOT be reduced to unrelated binary relationships
  when reduction loses semantics

# ---------- DIRECTION ----------
relationship_direction:
  - directed
  - undirected
  - bidirectional
  - inverse_defined
  - context_dependent

rule direction:
  directed relationship MUST preserve source and target roles

rule reversal:
  directed relationship MUST NOT be reversed
  unless inverse semantics permit

# ---------- INVERSE ----------
entity InverseRelationship:
  subtype_of: Relationship
  may_include:
    - original_predicate
    - inverse_predicate

rule inverse:
  inverse relationship MAY be inferred
  only when explicitly defined by predicate semantics

rule inverse_identity:
  inverse relationship != original relationship

# ---------- SYMMETRY ----------
entity SymmetricRelationship:
  subtype_of: Relationship

rule symmetry:
  IF predicate is symmetric
  THEN relation(a,b) MAY imply relation(b,a)

rule non_symmetric:
  symmetry MUST NOT be assumed
  from ordinary language alone

# ---------- TRANSITIVITY ----------
entity TransitiveRelationship:
  subtype_of: Relationship

rule transitivity:
  IF predicate is transitive
  AND relation(a,b)
  AND relation(b,c)
  THEN MAY infer relation(a,c)

rule non_transitive:
  transitivity MUST NOT be inferred
  without predicate semantics

# ---------- REFLEXIVITY ----------
entity ReflexiveRelationship:
  subtype_of: Relationship

rule reflexivity:
  reflexive predicate MAY permit relation(a,a)

rule self_relation:
  self-relation != reflexivity of predicate automatically

# ---------- ARITY ----------
entity RelationshipArity:
  type: StructuralMetadata
  may_be:
    - unary
    - binary
    - ternary
    - n_ary

rule arity:
  relationship arity SHOULD preserve number
  and roles of semantic participants

# ---------- CARDINALITY ----------
entity RelationshipCardinality:
  type: ConstraintMetadata
  may_be:
    - zero_or_one
    - exactly_one
    - zero_or_many
    - one_or_many
    - one_to_one
    - one_to_many
    - many_to_one
    - many_to_many

rule cardinality:
  relationship cardinality SHOULD be interpreted
  within predicate and ontology scope

# ---------- DOMAIN / RANGE ----------
entity RelationshipDomain:
  type: TypeConstraint

entity RelationshipRange:
  type: TypeConstraint

rule domain:
  source participant SHOULD satisfy predicate domain

rule range:
  target participant SHOULD satisfy predicate range

rule type_validation:
  domain or range violation SHOULD trigger validation
  rather than silent coercion

# ---------- ROLE ----------
entity RelationshipRole:
  type: SemanticRole
  may_include:
    - role_identifier
    - role_name
    - participant
    - constraints

rule role:
  participant identity != participant role

# ---------- CONTEXT ----------
entity RelationshipContext:
  type: ContextMetadata
  may_include:
    - ontology
    - domain
    - scope
    - temporal_context
    - spatial_context
    - application_context
    - interpretation_constraints

rule context:
  relationship meaning SHOULD preserve applicable context

rule context_change:
  same participants and predicate MAY represent
  different relationship state under different context

# ---------- TEMPORAL VALIDITY ----------
entity RelationshipTemporalState:
  type: TemporalMetadata
  may_include:
    - valid_from
    - valid_until
    - assertion_time
    - observation_time

rule temporal:
  relationship validity MAY change over time

rule historical:
  historically valid relationship != currently valid relationship

# ---------- ASSERTED / INFERRED ----------
entity AssertedRelationship:
  subtype_of: Relationship

entity InferredRelationship:
  subtype_of: Relationship
  may_include:
    - premises
    - inference_rule
    - confidence

rule assertion:
  asserted relationship != inferred relationship

rule inference:
  inferred relationship SHOULD preserve inference rule,
  premises, confidence, and provenance

# ---------- EXPLICIT / IMPLICIT ----------
entity ExplicitRelationship:
  subtype_of: Relationship

entity ImplicitRelationship:
  subtype_of: Relationship

rule implicit:
  implicit relationship MUST NOT be presented as explicit
  without supporting representation or evidence

# ---------- RELATIONSHIP VS ATTRIBUTE ----------
entity Attribute:
  type: Property

rule attribute_relationship:
  attribute != relationship automatically

rule relational_attribute:
  property referring to another semantic resource
  MAY be modelled as relationship when ontology semantics require

# ---------- RELATIONSHIP VS CO-OCCURRENCE ----------
entity CoOccurrence:
  type: ObservationalAssociation

rule cooccurrence:
  co-occurrence != semantic relationship automatically

# ---------- RELATIONSHIP VS SIMILARITY ----------
entity Similarity:
  type: ComparisonMetadata

rule similarity:
  similarity != semantic identity

rule similarity_relation:
  similarity MAY support relatedness
  but MUST NOT imply equivalence automatically

# ---------- RELATIONSHIP VS CORRELATION ----------
entity Correlation:
  type: StatisticalRelationship

rule correlation:
  statistical correlation != causation

# ---------- RELATIONSHIP VS CAUSATION ----------
entity Causation:
  type: CausalRelationship

rule causation:
  causal relationship requires causal semantics or evidence

rule association:
  association != causation

# ---------- RELATIONSHIP VS EQUIVALENCE ----------
entity SemanticEquivalenceRelationship:
  subtype_of: Relationship

rule equivalence:
  semantic equivalence requires stronger evidence
  than similarity or relatedness

rule relatedness:
  related_to != equivalent_to

# ---------- HIERARCHY ----------
entity HierarchicalRelationship:
  subtype_of: Relationship
  may_be:
    - parent_of
    - child_of
    - broader_than
    - narrower_than
    - superclass_of
    - subclass_of

rule hierarchy:
  hierarchy direction MUST be preserved

rule hierarchy_distinction:
  broader_than != parent_of automatically

# ---------- TAXONOMY ----------
entity TaxonomicRelationship:
  subtype_of: Relationship
  may_be:
    - is_a
    - subclass_of
    - instance_of
    - type_of

rule taxonomy:
  instance_of != subclass_of

# ---------- PART-WHOLE ----------
entity PartWholeRelationship:
  subtype_of: Relationship
  may_be:
    - part_of
    - has_part
    - component_of
    - member_of

rule part_whole:
  part_of != is_a

rule membership:
  member_of != subclass_of

# ---------- DEPENDENCY ----------
entity DependencyRelationship:
  subtype_of: Relationship
  may_be:
    - depends_on
    - required_by
    - prerequisite_of
    - uses
    - provides

rule dependency:
  dependency != equivalence

# ---------- CONFIDENCE ----------
entity RelationshipConfidence:
  type: EpistemicMetadata
  range: [0.0, 1.0]
  may_include:
    - score
    - method
    - evidence
    - source
    - assessment_time

rule confidence_bounds:
  REQUIRE 0.0 <= confidence <= 1.0

rule confidence:
  confidence in relationship != relationship truth guarantee

# ---------- PROVENANCE ----------
entity RelationshipProvenance:
  type: ProvenanceMetadata
  may_include:
    - relationship_identifier
    - source
    - creator
    - assertion_time
    - evidence
    - derivation
    - transformation
    - ontology_version
    - validation_events

rule provenance:
  relationship SHOULD preserve origin
  and derivation where available

# ---------- VALIDATION ----------
validation:
  require:
    - identifiable_relationship
    - predicate
    - participants

  validate_if_present:
    - direction
    - arity
    - cardinality
    - domain
    - range
    - participant_roles
    - context
    - temporal_state
    - confidence
    - provenance

  reject:
    - relationship_label_presented_as relationship_identity
    - directed_relationship_reversed_without inverse_semantics
    - non_symmetric_predicate_presented_as symmetric
    - non_transitive_predicate_used_transitively
    - participant_identity_presented_as participant_role
    - n_ary_relationship_flattened_with semantic_loss
    - cooccurrence_presented_as semantic_relationship_without evidence
    - similarity_presented_as identity
    - correlation_presented_as causation
    - association_presented_as causation
    - relatedness_presented_as equivalence
    - instance_of_presented_as subclass_of
    - part_of_presented_as is_a
    - inferred_relationship_presented_as asserted_relationship

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE:
  "relationship" ~= "semantic connection between two or more participants"
  "relationship predicate" ~= "semantic type defining the meaning of a relationship"
  "relationship participant" ~= "semantic resource occupying a role in a relationship"
  "relationship direction" ~= "orientation of participant roles within a relationship"
  "relationship arity" ~= "number of participants represented by a relationship"
  "relationship provenance" ~= "metadata describing origin and derivation of a relationship"

  PRESERVE distinctions:
    relationship_identity != relationship_label
    relationship != entity
    relationship != attribute
    participant_identity != participant_role
    relationship != inverse_relationship
    directed != symmetric
    binary_relationship != n_ary_relationship
    cooccurrence != semantic_relationship
    similarity != identity
    correlation != causation
    association != causation
    relatedness != equivalence
    instance_of != subclass_of
    part_of != is_a
    asserted_relationship != inferred_relationship
    historical_validity != current_validity

# ---------- CONFIDENCE ----------
CONFIDENCE:
  explicit_relationship_metadata:
    score: 1.00

  explicit_predicate_and_participants:
    score: 1.00

  validated_domain_and_range:
    score: 0.99

  explicit_inverse_semantics:
    score: 0.99

  evidence_supported_inferred_relationship:
    score: <= 0.95

  similarity_supported_relatedness:
    score: <= 0.80

  cooccurrence_only:
    score: <= 0.55

  incomplete_relationship_provenance:
    score: <= 0.55
    action: preserve uncertainty

# ---------- UPDATE MODEL ----------
UPDATE_MODEL:
  on_relationship_creation:
    - assign RelationshipIdentifier
    - identify predicate and participants
    - identify participant roles
    - determine direction and arity
    - validate domain, range, and cardinality
    - preserve context
    - initialise confidence and provenance

  on_relationship_change:
    - preserve previous relationship state
    - identify changed predicate, participant, role, direction, context, or validity
    - validate semantic impact
    - update provenance

  on_inference:
    - inspect predicate symmetry, transitivity, reflexivity, and inverse semantics
    - validate premises
    - infer relationship only when permitted
    - preserve inference confidence and provenance

  on_context_change:
    - preserve previous context
    - reassess relationship interpretation and validity
    - update confidence where required
    - preserve provenance

# ---------- FLOW HASH ----------
FLOW_HASH:
  inputs:
    - ontology
    - relationship_entities
    - predicates
    - participant_rules
    - direction_rules
    - inverse_rules
    - arity_rules
    - cardinality_rules
    - domain_range_rules
    - context_rules
    - temporal_rules
    - validation
    - semantic_equivalence
    - confidence_model
    - update_model

  canonicalisation:
    - preserve_relationship_identifier
    - preserve_predicate_identity
    - preserve_participant_identity_and_roles
    - preserve_direction
    - preserve_inverse_semantics
    - preserve_arity
    - preserve_cardinality
    - preserve_domain_and_range
    - preserve_context
    - preserve_temporal_validity
    - preserve_confidence
    - preserve_provenance
    - preserve_rule_order

  output:
    deterministic_semantic_hash

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION:
  interpret_as:
    - foundational relationship ontology
    - semantic predicate, participant, role, direction, arity, cardinality, domain, and range model
    - asserted and inferred relationship reasoning structure
    - confidence-aware and provenance-aware relationship representation

  operations:
    - identify relationships and participants
    - resolve predicates and participant roles
    - preserve relationship direction
    - resolve valid inverse relationships
    - inspect symmetry, transitivity, and reflexivity
    - validate arity and cardinality
    - validate domain and range
    - preserve semantic and temporal context
    - distinguish relationships from attributes and observations
    - distinguish similarity, correlation, causation, and equivalence
    - distinguish asserted and inferred relationships
    - trace confidence and provenance

  constraints:
    - do_not_equate_relationship_label_with relationship_identity
    - do_not_reverse_directional_relationship_without inverse_semantics
    - do_not_assume_symmetry_transitivity_or_reflexivity
    - do_not_flatten_n_ary_relationship_with semantic_loss
    - do_not_equate_cooccurrence_with semantic_relationship
    - do_not_equate_similarity_with identity
    - do_not_equate_correlation_or_association_with causation
    - do_not_equate_relatedness_with equivalence
    - do_not_equate_instance_of_with subclass_of
    - do_not_equate_part_of_with is_a
    - preserve_predicate_participants_roles_direction_context_confidence_and_provenance

# ---------- QUERY MODEL ----------
query:
  input:
    - relationship_identifier
    - predicate_identifier
    - participant_identifier
    - relationship_type
    - ontology
    - context
    - validity_time

  resolve:
    1. identify Relationship
    2. resolve predicate and participants
    3. resolve participant roles and direction
    4. inspect inverse semantics
    5. validate arity, cardinality, domain, and range
    6. inspect symmetry, transitivity, and reflexivity
    7. classify relationship family
    8. inspect context and temporal validity
    9. inspect confidence and provenance
    10. return relationship interpretation

  output:
    - relationship
    - relationship_identifier
    - predicate
    - participants
    - participant_roles
    - direction
    - inverse
    - arity
    - cardinality
    - domain
    - range
    - context
    - temporal_state
    - confidence
    - provenance

# ---------- INFERENCE ----------
inference:
  IF predicate defines valid inverse
  THEN MAY infer inverse relationship

  IF predicate is symmetric
  THEN MAY infer reversed participant relationship

  IF predicate is transitive
  AND valid relationship chain exists
  THEN MAY infer transitive relationship

  IF evidence indicates only co-occurrence, similarity, or correlation
  THEN do_not infer identity, equivalence, or causation

# ---------- OUTPUT CONTRACT ----------
output:
  ontology_entity: Relationship
  relationship_identity: machine_interpretable
  predicates: explicit
  participants_and_roles: explicit
  direction: preserved
  inverse_semantics: explicit
  arity: explicit
  cardinality: constrained
  domain_and_range: validated
  context: preserved
  temporal_validity: explicit
  asserted_and_inferred: distinguishable
  relationship_families: distinguishable
  confidence: explicit
  provenance: preserved
  uncertainty: explicit
  AI_reasoning: enabled

end flow