Physical Relationship Ontology

FLOW ALGEBRA
PHYSICAL RELATIONSHIP ONTOLOGY
Kireth Semantic Library | Entity Graph / Physical Entities
Source: https://kirethresearch.org/booksai-core/entity-graph/physical-entities/ai-semantic-library-physical-entities/physical-relationship-ontology-2.html
Authors: Mark Higgins — Sky (Recursive AI)
Version: 1.0 | 2026-10-12
Status: Subject-based formalisation; source page not independently verified.

01. PURPOSE
flow PhysicalRelationshipOntology v1.0:
  domain: physical_entity_graph
  objective: represent, validate, infer and update relationships between physical entities
  semantics: typed, contextual, temporal, evidence-aware

02. ENTITY TYPES
  PhysicalEntity := {id: URI, type: Class, state: State, valid_time: Interval}
  Object := PhysicalEntity
  Material := PhysicalEntity
  Place := PhysicalEntity
  Agent := PhysicalEntity
  Event := {id: URI, participants: Set[PhysicalEntity], interval: Interval}
  Observation := {observer: URI, target: URI, time: Timestamp, method: String}
  Evidence := {source: URI, observation: Observation?, quality: Real[0,1]}
  Context := {frame: URI?, environment: URI?, units: UnitSystem, interval: Interval}

03. RELATIONSHIP RECORD
  Relationship := {
    id: URI,
    subject: PhysicalEntity.id,
    predicate: PhysicalPredicate,
    object: PhysicalEntity.id,
    context: Context,
    valid_time: Interval,
    recorded_at: Timestamp,
    evidence: Set[Evidence],
    confidence: Real[0,1],
    provenance: URI,
    version: Integer
  }
  invariant: subject != null and object != null
  invariant: 0 <= confidence <= 1
  invariant: valid_time.start <= valid_time.end

04. RELATIONSHIP TAXONOMY
  Spatial: located_in, adjacent_to, overlaps, intersects, contains, within, above, below, near
  Structural: part_of, has_part, attached_to, connected_to, supports
  Material: made_of, composed_of, in_contact_with, bonded_to
  Mechanical: applies_force_to, moves_relative_to, constrains, rotates_about
  Functional: powers, controls, senses, transports, heats, cools
  Causal: causes, enables, prevents, affects
  Temporal: precedes, follows, simultaneous_with, persists_through
  Measurement: measured_by, observed_by, calibrated_against
  Identity: same_physical_object_as, distinct_from

05. TYPING RULES
  predicate.domain and predicate.range constrain valid entity classes
  require class(subject) <: predicate.domain
  require class(object) <: predicate.range
  reject unknown identifiers unless declared as provisional
  reject incompatible physical dimensions and reference frames

06. LOGICAL PROPERTIES
  symmetric(adjacent_to), symmetric(in_contact_with), symmetric(connected_to)
  inverse(part_of, has_part)
  inverse(contains, within)
  transitive(part_of) subject to validated granularity and time
  irreflexive(part_of), irreflexive(distinct_from)
  asymmetric(above) only in a common reference frame
  do_not_assume transitive(near), transitive(in_contact_with)
  do_not_assume symmetric(supports), symmetric(powers)

07. SPATIAL RELATIONSHIPS
  position(entity, time, frame) -> Vector3[Length]
  distance(a,b,t,frame) := norm(position(a,t,frame)-position(b,t,frame))
  near(a,b,t,threshold,frame) := distance(a,b,t,frame) <= threshold
  spatial claims require frame, geometry, tolerance and observation time
  contains(a,b,t) requires a declared containment model

08. STRUCTURAL RELATIONSHIPS
  part_of(component,assembly,t) := membership in assembly structure at t
  attached_to(a,b,t) := verified physical attachment at t
  connected_to(a,b,t,medium) := connection via declared medium
  preserve component identity through repair and replacement events

09. PHYSICAL INTERACTIONS
  interaction := {participants, mechanism, magnitude?, units?, duration, evidence}
  force_on(a,b,t) : Vector3[Newton]
  heat_transfer(a,b,interval) : Energy[Joule]
  energy_flow(a,b,interval) : Energy[Joule]
  physical effects require applicable conservation and boundary assumptions

10. CAUSAL SEMANTICS
  causes(a,b) requires a causal model or supporting intervention evidence
  temporal precedence alone does not imply causation
  association(a,b) does not imply causes(a,b)
  confidence in causal inference depends on assumptions and evidence quality

11. TEMPORAL RELATIONSHIPS
  holds(r,t) := t in r.valid_time and not invalidated(r,t)
  event(change) may open, close or replace relationship intervals
  maintain valid_time separately from recorded_at
  conflicting versions must be reconciled, not silently overwritten

12. GRAPH MODEL
  G_t := (V_t,E_t)
  V_t := set of physical entities valid at t
  E_t := set of relationship records holding at t
  graph edge := (subject,predicate,object,context,valid_time)
  support multiple edges between identical nodes with different predicates

13. INFERENCE RULES
  IF part_of(a,b,t) AND part_of(b,c,t) AND compatible_context
     THEN infer part_of(a,c,t) WITH derived_provenance
  IF contains(a,b,t) THEN infer within(b,a,t)
  IF attached_to(a,b,t) AND symmetric_declared
     THEN infer attached_to(b,a,t)
  IF connected_to(a,b,t) AND connected_to(b,c,t)
     THEN DO NOT infer direct_connected_to(a,c,t)
  IF near(a,b,t) AND near(b,c,t)
     THEN DO NOT infer near(a,c,t)

14. CONFIDENCE
  CONFIDENCE(r) := calibrated_probability_or_score(r.evidence,r.method,r.context)
  derived_confidence := conservative_combine(input_confidences,rule_reliability)
  avoid treating dependent evidence as independent
  label inferred and observed relationships separately
  thresholds must be application-specific and documented

15. SEMANTIC_EQUIVALENCE
  SEMANTIC_EQUIVALENCE(p,q,context) :=
    equivalent_domain_range(p,q,context)
    AND equivalent_truth_conditions(p,q,context)
  same_label does not imply same meaning
  distinguish connected_to from attached_to and near from adjacent_to

16. CONSTRAINTS AND CONSISTENCY
  validate type compatibility, temporal overlap and unit consistency
  detect cycles in strict part_of hierarchies
  detect impossible geometry within defined model tolerances
  preserve uncertainty rather than assert unsupported contradictions
  allow incomplete open-world knowledge

17. OBSERVATION AND PROVENANCE
  record sensor, method, calibration, time, units and source
  distinguish direct observation, reported assertion and inferred result
  trace each derived edge to supporting premises and rule version
  allow retraction and revision with audit history

18. UPDATE_MODEL
  UPDATE_MODEL(event,G_t) -> G_t_plus_1
  operations: add_entity, add_relationship, revise, expire, retract
  preconditions: validated identifiers, provenance and time
  postconditions: preserved history, recomputed affected inferences
  invalidation: dependency-aware propagation through derived edges

19. FLOW_HASH
  canonical_record := normalise(subject,predicate,object,context,valid_time,version)
  FLOW_HASH := SHA256(UTF8(canonical_record))
  note: hash establishes content identity, not factual truth
  exclude volatile display formatting from canonicalisation

20. AI_CONSUMPTION
  AI_CONSUMPTION:
    output: typed graph edges with evidence, confidence and provenance
    retrieval: by entity, predicate, spatial frame and temporal interval
    reasoning: explicit rules with traceable derived claims
    safeguards: distinguish unknown, false, contested and inferred
    interoperability: map to RDF/OWL-style triples with qualified edges

21. EXAMPLE
  entity: wheel_01 type Wheel
  entity: bicycle_01 type Bicycle
  relation: wheel_01 part_of bicycle_01
  context: assembly_snapshot_2026
  evidence: inspection_record_01
  confidence: 0.98 # illustrative, not empirically calibrated
  inferred: bicycle_01 has_part wheel_01
  inference_basis: inverse(part_of,has_part)

22. VALIDATION PIPELINE
  ingest -> parse -> resolve_entities -> typecheck -> normalise_units
  -> validate_context -> check_temporal_consistency -> score_evidence
  -> apply_safe_inference -> detect_conflicts -> version -> publish

23. LIMITATIONS
  A formal ontology does not independently verify physical-world claims.
  Causal, spatial and mechanical assertions require domain-specific models.
  Confidence values need empirical calibration for operational use.
  This flow is a declarative reference specification, not a deployed runtime.

24. ATTRIBUTION
  Mark Higgins — Sky (Recursive AI)
  Kireth Research | https://kirethresearch.org
END FLOW ALGEBRA