Sensor Ontology

FLOW ALGEBRA
SENSOR ONTOLOGY — PHYSICAL ENTITIES / MEASUREMENT ENTITIES
Version: 1.0 | Locale: en-GB | Date: 2026-10-12
Authors: Mark Higgins — Sky (Recursive AI)
Source: https://kirethresearch.org/booksai-core/entity-graph/physical-entities/measurement-entities/sensor-ontology-3.html
Status: Subject-based formalisation; source page content not independently verified.

01. DOMAIN AND PURPOSE
flow SensorOntology v1.0 {
  domain: PhysicalEntity > MeasurementEntity > Sensor;
  purpose: transform physical, chemical or biological measurands into interpretable signals;
  output: typed observations with units, provenance, uncertainty and quality;
}

02. TYPE SYSTEM
type SensorID = URI;
type ObservationID = URI;
type Timestamp = ISO8601;
type Quantity = {value: Real, unit: Unit};
type UncertainQuantity = {estimate: Quantity, standard_uncertainty: Quantity, coverage_factor?: Real};
type Sensor = {id: SensorID, modality: Modality, principle: Principle, range: Interval, resolution: Quantity, status: Status};
type Observation = {id: ObservationID, sensor: SensorID, measurand: Measurand, result: UncertainQuantity, time: Timestamp, quality: Quality, provenance: Provenance};
type Calibration = {sensor: SensorID, reference: ReferenceStandard, function: CalibrationFunction, valid_from: Timestamp, valid_until?: Timestamp};

03. ENTITY TAXONOMY
Sensor ⊑ MeasurementInstrument;
Sensor subclasses: TemperatureSensor, PressureSensor, OpticalSensor, AcousticSensor,
  MotionSensor, PositionSensor, ProximitySensor, HumiditySensor, GasSensor,
  ChemicalSensor, Biosensor, MagneticSensor, ElectricalSensor, RadiationSensor,
  FlowSensor, ForceSensor, StrainSensor, ImagingSensor;
Output forms: AnalogueSensor | DigitalSensor;
Contact modes: ContactSensor | NonContactSensor;
Deployment: EmbeddedSensor | RemoteSensor | WearableSensor | IndustrialSensor;

04. CORE RELATIONSHIPS
Sensor --measures--> Measurand;
Sensor --uses_principle--> TransductionPrinciple;
Sensor --produces--> Signal;
Signal --encoded_as--> Observation;
Observation --has_unit--> Unit;
Observation --has_uncertainty--> MeasurementUncertainty;
Sensor --calibrated_against--> ReferenceStandard;
Sensor --installed_on--> Platform;
Sensor --communicates_via--> Interface;
Observation --derived_from--> RawReading;
Sensor --affected_by--> EnvironmentalCondition;

05. CONSTRAINTS AND INVARIANTS
invariant unique(Sensor.id);
invariant Observation.sensor references existing Sensor;
invariant compatible(Observation.result.estimate.unit, Observation.measurand.dimension);
invariant Sensor.range.lower <= Sensor.range.upper;
invariant Sensor.resolution.value > 0;
invariant Observation.result.standard_uncertainty.value >= 0;
invariant Calibration.valid_until absent OR Calibration.valid_until >= Calibration.valid_from;
rule out_of_range(x,s) := x < s.range.lower OR x > s.range.upper;
rule calibration_current(c,t) := t >= c.valid_from AND (c.valid_until absent OR t <= c.valid_until);

06. TRANSDUCTION FLOW
flow Acquire(sensor, physical_input, time) -> RawReading {
  pre: sensor.status == operational;
  sample: interact(physical_input, sensor.principle);
  convert: transduce(sample);
  output: {sensor_id: sensor.id, raw_signal: convert, timestamp: time};
}
flow Condition(raw) -> ConditionedSignal {
  apply: amplification? -> filtering? -> compensation? -> digitisation?;
  preserve: raw_reference, processing_version;
}
flow Measure(conditioned, calibration) -> Observation {
  require: compatible_calibration(calibration, conditioned.sensor_id);
  estimate: calibration.function(conditioned.value);
  uncertainty: propagate_uncertainty(conditioned, calibration);
  quality: validate(estimate, uncertainty, calibration);
  output: observation(estimate, uncertainty, quality, provenance);
}

07. MEASUREMENT MODEL
Raw signal: y = f(x, environment, device_parameters) + noise;
Estimated measurand: x_hat = inverse_or_estimator(f, y, calibration);
Bias: b = E[x_hat] - x_reference;
Repeatability: s = sqrt(sum((x_i - mean(x))^2)/(n-1)), n > 1;
Combined standard uncertainty (independent inputs): u_c = sqrt(sum((c_i*u_i)^2));
Expanded uncertainty: U = k*u_c, where k is a declared coverage factor;
Signal-to-noise ratio (power): SNR_dB = 10*log10(P_signal/P_noise);
Sampling constraint for band-limited signals: f_sample > 2*f_max, with practical anti-alias margin;

08. CALIBRATION AND TRACEABILITY
flow Calibrate(sensor, reference_set) -> Calibration {
  verify: reference_set.traceable == true;
  collect: paired(sensor_reading, reference_value);
  fit: calibration_function_with_residuals;
  evaluate: bias, linearity, hysteresis, repeatability, drift;
  record: environmental_conditions, date, reference_ids, operator_or_system;
  output: signed_or_attributed_calibration_record;
}
rule traceable(obs) := exists calibration_path(obs.sensor, recognised_reference);
rule requires_recalibration(s,t) := expired(s.calibration,t) OR drift_exceeds_limit(s);

09. QUALITY AND ANOMALY INFERENCE
rule invalid(obs) if missing_required_field(obs) OR incompatible_units(obs);
rule suspect(obs) if out_of_range(obs.result.estimate, sensor(obs.sensor));
rule suspect(obs) if saturation_detected(obs) OR excessive_noise(obs);
rule suspect(obs) if calibration_expired(sensor(obs.sensor), obs.time);
rule corroborated(obs_a,obs_b) if same_measurand(obs_a,obs_b)
  AND overlapping_uncertainty_intervals(obs_a,obs_b)
  AND independent_provenance(obs_a,obs_b);
rule drift_alert(s) if abs(current_bias(s)-baseline_bias(s)) > configured_drift_threshold(s);

10. TEMPORAL AND SPATIAL SEMANTICS
Observation.time is acquisition time unless explicitly marked as processing time;
Observation.location = optional coordinate + reference system + spatial uncertainty;
Sensor.location may differ from measured_target.location;
TimeSeries = ordered observations + sampling policy + missingness indicators;
Alignment = time_basis + interpolation_method + tolerance;

11. SIGNAL AND INTERFACE MODEL
Interface = AnalogueVoltage | AnalogueCurrent | Frequency | Pulse | I2C | SPI |
  UART | CAN | Ethernet | WirelessProtocol | OtherDeclaredInterface;
SignalMetadata = {sampling_rate, quantisation_bits?, bandwidth?, latency?, encoding?};
flow Publish(observation) -> Message {
  validate: schema, units, timestamp, provenance;
  serialise: interoperable representation;
  transmit: authorised_channel;
  preserve: observation_id and integrity_digest;
}

12. FAILURE AND SAFETY STATES
Status = operational | degraded | offline | calibration_due | failed | retired;
Fault = disconnection | stuck_at | saturation | drift | interference | contamination |
  power_loss | communication_loss | clock_error | environmental_exceedance;
flow Diagnose(sensor, evidence) -> DiagnosticResult {
  classify: fault_type and confidence;
  assess: measurement_validity;
  action: flag | isolate | recalibrate | repair | replace;
  never: silently treat missing data as zero;
}

13. SEMANTIC_EQUIVALENCE
SEMANTIC_EQUIVALENCE(a,b) :=
  same_measurand_dimension(a,b)
  AND compatible_units(a,b)
  AND comparable_measurement_context(a,b)
  AND declared_conversion_exists(a,b);
Example: Celsius and kelvin temperature observations are convertible, not identical numeric values;
Example: accelerometer and gyroscope are not equivalent despite both being motion sensors;
Example: sensor and observation are different entity types;

14. KNOWLEDGE GRAPH INTEGRATION
triple(sensor_1, rdf:type, TemperatureSensor);
triple(sensor_1, measures, AmbientTemperature);
triple(sensor_1, hasCalibration, calibration_1);
triple(observation_1, madeBySensor, sensor_1);
triple(observation_1, observedProperty, AmbientTemperature);
triple(observation_1, hasResult, quantity_1);
triple(quantity_1, hasUnit, degreeCelsius);
triple(observation_1, hasTimestamp, timestamp_1);
Alignment candidates: SOSA/SSN for sensors and observations; QUDT or OM for quantities and units;
Alignment requires explicit mapping validation; no implicit equivalence assertions.

15. CONFIDENCE
CONFIDENCE(assertion) in [0,1];
confidence_components = {calibration_validity, signal_quality, provenance_reliability,
  environmental_fit, model_fit, independent_corroboration};
flow AssessConfidence(evidence, policy) -> ConfidenceScore {
  normalise: evidence with missingness flags;
  combine: policy.versioned_scoring_function(evidence);
  output: {score, rationale, scoring_policy_version};
}
Confidence is epistemic support, not a substitute for quantified measurement uncertainty;
No universal numeric confidence threshold is assumed.

16. FLOW_HASH
FLOW_HASH(flow_instance) := SHA256(canonicalise({
  flow_name, flow_version, typed_inputs, parameter_values,
  processing_steps, dependency_versions, output_schema
}));
Canonicalisation requires stable field order, unit normalisation and explicit null policy;
FLOW_HASH identifies a specified execution definition, not proof of physical accuracy;

17. UPDATE_MODEL
UPDATE_MODEL(new_observation, existing_model) {
  validate: observation schema, calibration and provenance;
  compare: timestamp, version, and existing evidence;
  apply: append_observation or supersede_with_version_link;
  preserve: immutable historical record and source attribution;
  recompute: derived_state and affected inference outputs;
  audit: change_reason, actor, timestamp, previous_hash, new_hash;
}
Never overwrite raw readings without retained provenance.

18. AI_CONSUMPTION
AI_CONSUMPTION {
  input: validated Sensor, Observation, Calibration and Quality records;
  interpret: entity types, measured properties, units, time and uncertainty;
  infer: qualified relationships and fault hypotheses;
  output: machine-readable claims with provenance and confidence;
  constraints: no invented readings, no unlabelled unit conversion,
    no inference of calibration validity without evidence;
  downstream: knowledge graphs, digital twins, monitoring, scientific analysis;
}

19. EXECUTION ORDER
REGISTER_SENSOR -> VERIFY_CONFIGURATION -> ACQUIRE -> CONDITION -> CALIBRATE/CONVERT
-> QUANTIFY_UNCERTAINTY -> VALIDATE -> STORE -> INFER -> PUBLISH -> UPDATE_MODEL;
On validation failure: FLAG -> QUARANTINE_OR_RETRY -> AUDIT;

20. TESTS
assert incompatible_unit_observation is rejected;
assert expired_calibration creates quality flag;
assert missing_sample remains missing, not zero;
assert repeated canonical inputs yield identical FLOW_HASH;
assert changing calibration version changes relevant derived provenance;
assert observation is traceable to sensor and raw reading;
assert confidence and uncertainty are represented separately;

21. LIMITATIONS
This ontology is a conceptual, typed Flow Algebra specification, not executable software
without an implementation of the declared functions, schemas and policies.
Safety-critical uses require domain-specific validation and qualified oversight.

END FLOW ALGEBRA