Physical Observation Ontology

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

01. PURPOSE
flow PhysicalObservationOntology v1.0:
  domain: physical_entities
  purpose: represent observations of physical objects, processes, states and properties with provenance, uncertainty and repeatability
  inputs: [observation_records, instruments, observers, targets, contexts, calibrations]
  outputs: [validated_observations, physical_entity_graph, inferred_claims, audit_trail]

02. TYPE SYSTEM
type EntityID = str
type Timestamp = ISO8601
type Quantity = {value: float, unit: str, uncertainty?: float}
type Interval = {start: Timestamp, end: Timestamp}
type Confidence = float in [0,1]
type ObservationStatus = enum{raw, validated, qualified, rejected, superseded}
type ObservationMode = enum{direct, instrumented, remote, inferred}
type EvidenceKind = enum{sensor_reading, image, spectrum, waveform, manual_record, derived_record}

03. TYPED ENTITIES
entity PhysicalEntity {id: EntityID, class: str, identity_confidence: Confidence}
entity PhysicalProperty {id: EntityID, quantity_kind: str, dimension: str}
entity PhysicalState {id: EntityID, entity_id: EntityID, valid_time: Interval}
entity PhysicalProcess {id: EntityID, participants: list[EntityID], valid_time: Interval}
entity Observer {id: EntityID, kind: enum{human, instrument, autonomous_system}}
entity Instrument {id: EntityID, model: str, serial?: str, calibration_id?: EntityID}
entity Sensor {id: EntityID, instrument_id?: EntityID, transfer_function?: str}
entity Observation {id: EntityID, target_id: EntityID, property_id?: EntityID, observer_id: EntityID, time: Timestamp, mode: ObservationMode, status: ObservationStatus}
entity Measurement {id: EntityID, observation_id: EntityID, result: Quantity, method_id: EntityID}
entity ObservationContext {id: EntityID, environment: map, location?: str, frame?: str}
entity Evidence {id: EntityID, kind: EvidenceKind, uri?: str, checksum?: str}
entity Calibration {id: EntityID, instrument_id: EntityID, valid_time: Interval, reference: str, uncertainty?: float}
entity Provenance {id: EntityID, agent_id: EntityID, method_id: EntityID, source_id: EntityID, recorded_at: Timestamp}
entity Claim {id: EntityID, subject_id: EntityID, predicate: str, object: any, confidence: Confidence}

04. SEMANTIC RELATIONSHIPS
relation OBSERVES(Observer, PhysicalEntity)
relation OBSERVATION_OF(Observation, PhysicalEntity)
relation OBSERVES_PROPERTY(Observation, PhysicalProperty)
relation PRODUCES(Observation, Measurement)
relation USES_INSTRUMENT(Observation, Instrument)
relation HAS_CONTEXT(Observation, ObservationContext)
relation SUPPORTED_BY(Observation, Evidence)
relation HAS_PROVENANCE(Observation, Provenance)
relation CALIBRATED_BY(Instrument, Calibration)
relation DESCRIBES_STATE(Observation, PhysicalState)
relation DESCRIBES_PROCESS(Observation, PhysicalProcess)
relation CORROBORATES(Observation, Observation)
relation CONFLICTS_WITH(Observation, Observation)
relation DERIVED_FROM(Claim, Observation)
relation SUPERSEDES(Observation, Observation)

05. INVARIANTS
invariant observation.target_id exists in PhysicalEntity
invariant observation.observer_id exists in Observer
invariant observation.time is timezone-aware
invariant measurement.observation_id exists in Observation
invariant measurement.result.unit compatible_with property.dimension
invariant confidence >= 0 and confidence <= 1
invariant rejected_observations not used as validated evidence
invariant every validated observation has provenance and method
invariant evidence checksum verified when supplied

06. OBSERVATION ACQUISITION
flow AcquireObservation(target, observer, property, context, method):
  assert identity_resolved(target)
  t := clock.now_utc()
  raw := method.capture(target, context)
  observation := Observation(target, observer, property, t, method.mode, raw)
  link observation HAS_CONTEXT context
  link observation SUPPORTED_BY raw.evidence
  return observation

07. NORMALISATION
flow NormaliseObservation(observation):
  preserve raw_payload
  canonicalise timestamps to UTC
  map units to canonical SI representation where possible
  retain original units and conversion metadata
  align coordinate reference frames
  validate type and dimension compatibility
  return normalised_observation

08. CALIBRATION
flow ApplyCalibration(observation, instrument, time):
  calibration := find_valid_calibration(instrument, time)
  if calibration absent: flag uncalibrated; do not assert calibrated accuracy
  else: apply traceable correction and uncertainty contribution
  return qualified_result

09. UNCERTAINTY MODEL
model measured_value = true_value + systematic_error + random_error
model combined_standard_uncertainty = sqrt(sum(sensitivity_i^2 * variance_i) + covariance_terms)
rule report expanded_uncertainty only with stated coverage_factor
rule preserve distinction between precision, accuracy, resolution and uncertainty
rule instrument_uncertainty != observer_confidence

10. TEMPORAL SEMANTICS
rule observation_time != ingestion_time unless explicitly identical
rule observation_of_state valid only for specified temporal interval
rule successive observations do not imply continuous monitoring
rule delayed evidence retains original acquisition timestamp

11. SPATIAL SEMANTICS
rule each spatial measurement specifies reference frame where relevant
rule coordinate transformations preserve source frame and transform version
rule spatial proximity alone does not prove object identity

12. VALIDATION
flow ValidateObservation(o):
  check schema, target identity, provenance, timestamp, method
  check units, calibration status, range and sensor saturation
  check duplicate identifiers and evidence integrity
  if critical failure: status := rejected
  else if material caveat: status := qualified
  else: status := validated
  emit validation_report

13. REPEATABILITY AND REPRODUCIBILITY
rule repeated observations share controlled method and comparable context
rule independent observations may corroborate a claim
rule reproducibility requires accessible method and sufficient metadata
rule agreement is evaluated against combined uncertainty, not exact equality

14. CONFLICT RESOLUTION
flow Reconcile(a, b):
  if different_targets_or_properties: return non_comparable
  align units, times, contexts and calibration references
  if statistically_compatible(a, b): link CORROBORATES(a,b)
  else: link CONFLICTS_WITH(a,b); request investigation
  never silently overwrite contradictory evidence

15. PHYSICAL STATE INFERENCE
rule OBSERVATION_OF(o,e) and OBSERVES_PROPERTY(o,p) and validated(o)
  => candidate_state_property(e,p,o.value,o.time)
rule inference must retain provenance and uncertainty
rule inferred physical state is not equivalent to directly observed state

16. PROCESS INFERENCE
rule ordered observations of same entity may support a state transition
rule state_transition does not by itself establish a causal mechanism
rule causal claim requires independent assumptions or experimental evidence

17. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE:
  exact: same target, property, time interval, method semantics and compatible values
  approximate: comparable target/property with tolerances and uncertainty overlap
  prohibited: equating observations solely by label similarity
  output: {equivalence_type, mapping, assumptions, confidence}

18. CONFIDENCE
CONFIDENCE:
  components: [identity_quality, provenance_quality, calibration_quality, measurement_quality, replication_support]
  aggregation: declared, documented and calibrated for intended domain
  caution: confidence is not a replacement for physical measurement uncertainty
  output: {score: Confidence, rationale: str, limitations: list[str]}

19. GRAPH INTEGRATION
flow BuildObservationGraph(records):
  for o in records:
    upsert target, observer, context, instrument, evidence, provenance
    upsert observation with stable identifier
    create typed edges; validate domain/range
    preserve revisions as separate versions
  return versioned_physical_entity_graph

20. QUERY SEMANTICS
query observations_by_entity(entity_id, time_window)
query observations_by_property(property_id, context_filter)
query evidence_for_claim(claim_id)
query conflicting_observations(entity_id, property_id)
query calibration_lineage(observation_id)
query state_at_time(entity_id, timestamp)

21. FLOW_HASH
FLOW_HASH:
  algorithm: SHA-256
  canonical_payload: [ontology_version, normalised_entities, typed_edges, rules, provenance]
  exclude: [non_semantic_whitespace, volatile_rendering_metadata]
  output: lowercase_hex_digest
  requirement: deterministic canonical serialisation before hashing

22. UPDATE_MODEL
UPDATE_MODEL:
  strategy: append_only_versioning
  changes: [new_observation, correction, calibration_revision, identity_resolution, retraction]
  on_update:
    - validate new record
    - retain historical record and lineage
    - recompute affected claims and confidence
    - refresh impacted graph edges and FLOW_HASH
    - record reason, timestamp and responsible agent
  rule: never erase original evidence to conceal a correction

23. AI_CONSUMPTION
AI_CONSUMPTION:
  representation: typed machine-readable observations and evidence-linked claims
  required_fields: [entity_id, observation_id, observed_property, timestamp, value_or_state, provenance, status]
  optional_fields: [unit, uncertainty, confidence, spatial_context, calibration, semantic_mapping]
  reasoning_constraints:
    - distinguish observation from inference
    - distinguish correlation from causation
    - retain units and time qualifiers
    - expose conflicting evidence
    - avoid unsupported certainty
  output: grounded_answer_with_traceable_evidence

24. ERROR HANDLING
error MissingTargetIdentity => quarantine observation
error IncompatibleUnits => reject conversion until resolved
error ExpiredCalibration => qualify observation and flag review
error MissingProvenance => prohibit validated status
error EvidenceMismatch => reject and audit
error TimestampAmbiguity => request explicit time reference

25. EXECUTION PIPELINE
flow PhysicalObservationPipeline(input):
  raw := AcquireObservation(input.target, input.observer, input.property, input.context, input.method)
  normalised := NormaliseObservation(raw)
  calibrated := ApplyCalibration(normalised, input.instrument, raw.time)
  validated := ValidateObservation(calibrated)
  graph := BuildObservationGraph([validated])
  claims := infer_supported_claims(graph)
  return {observation: validated, graph: graph, claims: claims, flow_hash: FLOW_HASH(graph)}

26. TEST CASES
test valid_temperature_observation -> canonical_unit_kelvin_and_original_unit_preserved
test missing_calibration -> qualified_not_falsely_calibrated
test incompatible_dimensions -> validation_failure
test duplicate_observation_id -> idempotent_upsert_or_version_conflict
test conflicting_measurements -> both_retained_with_conflict_edge
test missing_evidence_provenance -> not_validated
test stable_canonical_graph -> identical_FLOW_HASH
test revised_calibration -> dependent_claims_recomputed

27. SCOPE AND LIMITATIONS
This algebra is an ontology-oriented specification, not an executable program without a compatible runtime and concrete schema bindings.
Observation validity depends on instrument specifications, scientific method, and domain-specific tolerances.
The source URL identifies the intended library page; this file does not claim to reproduce unseen page text.

END FLOW ALGEBRA