Physical Relationship Ontology

FLOW ALGEBRA
TITLE: Physical Relationship Ontology
VERSION: 1.0
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/scientific-relationships/physical-relationship-ontology.html
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "PhysicalRelationshipOntology" v1.0 {
  DOMAIN: ScientificRelationships.PhysicalRelationships
  PURPOSE: Represent, validate and reason over physically meaningful relationships between entities, quantities, processes and observations.

  TYPES {
    PhysicalEntity { id: URI, kind: String, properties: Map }
    PhysicalQuantity { id: URI, magnitude: Real, unit: SIUnit, uncertainty: Real? }
    PhysicalProcess { id: URI, inputs: Set<URI>, outputs: Set<URI> }
    PhysicalLaw { id: URI, expression: -Expression, assumptions: Set<Condition> }
    Observation { id: URI, subject: URI, quantity: URI, timestamp: DateTime?, method: String? }
    Relationship { subject: URI, predicate: Predicate, object: URI, context: Context, evidence: Set<URI> }
    Context { reference_frame: String?, environment: Map, temporal_scope: Interval?, assumptions: Set<Condition> }
  }

  RELATIONSHIPS {
    interacts_with(Entity, Entity)
    exerts_force_on(Entity, Entity, Force)
    transfers_energy_to(Entity, Entity, Energy)
    transfers_momentum_to(Entity, Entity, Momentum)
    located_relative_to(Entity, Entity, PositionVector, ReferenceFrame)
    moves_relative_to(Entity, Entity, VelocityVector, ReferenceFrame)
    transforms_into(State, State, Process)
    constrained_by(Process, PhysicalLaw)
    measured_as(Entity, PhysicalQuantity, Observation)
    physically_depends_on(Quantity, Quantity, Model)
  }

  RULES {
    R1: exerts_force_on(A,B,F) AND classical_newtonian_pair(A,B)
        => exerts_force_on(B,A,-F) [same interaction, same frame];
    R2: transfers_energy_to(A,B,E) AND closed_exchange(A,B)
        => energy_change(A) = -E AND energy_change(B) = E;
    R3: located_relative_to(A,B,r,F) => located_relative_to(B,A,-r,F);
    R4: measured_as(X,Q,O) => requires(unit_compatible(Q), uncertainty_documented(O));
    R5: physically_depends_on(X,Y,M) => requires(valid_model(M), assumptions_satisfied(M));
    R6: correlation(X,Y) != evidence_of_causation(X,Y) without causal justification;
    R7: inferred_relationship(R) => retain(evidence, context, rule_id, uncertainty);
  }

  SEMANTIC_EQUIVALENCE {
    exact_equivalence: same_physical_meaning AND compatible_dimensions AND same_context;
    approximate_equivalence: bounded_difference_under_declared_tolerance;
    non_equivalence: different_reference_frames_without_transform OR incompatible_dimensions;
  }

  CONFIDENCE {
    range: [0,1];
    evidence_factors: [measurement_quality, model_validity, reproducibility, provenance, contextual_fit];
    policy: propagate_uncertainty_and_do_not_inflate_confidence;
  }

  VALIDATION {
    require_unique_identifiers: true;
    require_dimensional_consistency: true;
    require_reference_frame_for_vector_comparisons: true;
    require_declared_assumptions: true;
    reject_unsupported_causal_claims: true;
    preserve_original_measurements: true;
  }

  FLOW_HASH {
    algorithm: SHA-256;
    input: canonical_serialisation(types, relationships, rules, context, version);
    output: deterministic_content_digest;
  }

  UPDATE_MODEL {
    versioned: true;
    preserve_provenance: true;
    record_changes: [timestamp, author, changed_entity, justification, prior_hash, new_hash];
    revalidate_dependents: true;
  }

  AI_CONSUMPTION {
    format: typed_semantic_graph;
    expose: [entities, predicates, physical_laws, evidence, uncertainty, provenance, context];
    reasoning: [dimensional_checking, rule_application, dependency_tracing, conflict_detection];
    safeguards: [no_unjustified_causality, no_implicit_unit_conversion, no_unlabelled_assumptions];
  }
}

END FLOW ALGEBRA