Spacecraft Ontology

FLOW ALGEBRA
SPACECRAFT ONTOLOGY — FULL EXECUTABLE SEMANTIC SPECIFICATION
Version: 1.0 | Date: 2026-10-12 | Locale: en-GB
Authors: Mark Higgins — Sky (Recursive AI)
Publisher: Kireth Research | https://kirethresearch.org
Source page: https://kirethresearch.org/booksai-core/entity-graph/physical-entities/artificial-entities/spacecraft-ontology.html
Source status: Live page not retrievable; domain-based ontology, not a verified transcription.

01. DOMAIN AND SCOPE
flow SpacecraftOntology v1.0 {
  domain: PhysicalEntity > ArtificialEntity > Spacecraft
  purpose: Represent designed vehicles capable of operation in space, their systems, missions, states, and evidence.
  semantics: typed, provenance-aware, temporally versioned
  world_assumption: open
}

02. TYPED ENTITY DECLARATIONS
type Entity { id: URI; label: String; description: String? }
type PhysicalEntity extends Entity { mass_kg: Real? }
type ArtificialEntity extends PhysicalEntity { manufacturer: Organisation? }
type Spacecraft extends ArtificialEntity {
  kind: SpacecraftKind; mission: Mission?; launch: LaunchEvent?;
  operational_state: OperationalState; systems: Set<Subsystem>;
  orbit: Orbit?; trajectory: Trajectory?; provenance: EvidenceSet
}
type Satellite extends Spacecraft { primary_body: CelestialBody? }
type SpaceProbe extends Spacecraft { target: CelestialBody? }
type CrewedSpacecraft extends Spacecraft { crew_capacity: Integer }
type CargoSpacecraft extends Spacecraft { payload_capacity_kg: Real? }
type Lander extends Spacecraft { landing_target: CelestialBody? }
type Rover extends Spacecraft { surface_mobility: MobilitySystem? }
type SpaceStation extends Spacecraft { habitable: Boolean }
type LaunchVehicle extends ArtificialEntity { stages: List<PropulsionStage> }
type Mission extends Entity { objectives: Set<O-bjective>; phases: List<MissionPhase> }
type Subsystem extends Entity { health: HealthState; components: Set<Component> }
type Component extends ArtificialEntity { status: HealthState }
type Orbit extends Entity { reference_body: CelestialBody; epoch: Time; elements: OrbitalElements }
type Trajectory extends Entity { reference_frame: ReferenceFrame; state_history: TimeSeries<StateVector> }
type Telemetry extends Entity { source: Component; timestamp: Time; measurement: Measurement }
type Command extends Entity { target: Component; timestamp: Time; authorisation: Authorisation }
type Evidence extends Entity { source_uri: URI?; observed_at: Time; confidence: Real }

enum SpacecraftKind { SATELLITE, PROBE, CREWED, CARGO, LANDER, ROVER, STATION, OTHER }
enum OperationalState { DESIGN, ASSEMBLY, TEST, LAUNCHED, COMMISSIONING, ACTIVE, SAFE_MODE, INACTIVE, DEORBITED, DISPOSED, LOST }
enum HealthState { NOMINAL, DEGRADED, FAILED, UNKNOWN }

03. COMPONENT AND SUBSYSTEM TAXONOMY
subsystem: Structure | Propulsion | GuidanceNavigationControl | ElectricalPower
         | ThermalControl | Communications | CommandDataHandling
         | AttitudeDeterminationControl | Payload | LifeSupport | LandingSystem
component: Thruster | ReactionWheel | StarTracker | Gyroscope | SolarArray
         | Battery | Antenna | Transponder | Computer | Sensor | Radiator
         | FuelTank | Valve | HeatShield | DockingMechanism
NOTE: Components and subsystems are roles; physical implementations vary by mission.

04. RELATIONSHIP SIGNATURES
is_a: Entity -> EntityType
part_of: Component -> Subsystem | Spacecraft
has_subsystem: Spacecraft -> Subsystem
carries_payload: Spacecraft -> Component
assigned_to: Spacecraft -> Mission
launched_by: Spacecraft -> LaunchVehicle
launched_at: Spacecraft -> LaunchEvent
operates_in: Spacecraft -> Orbit | Trajectory | SurfaceEnvironment
orbits: Satellite -> CelestialBody
lands_on: Lander -> CelestialBody
communicates_with: Spacecraft -> GroundStation | Spacecraft
powered_by: Subsystem -> ElectricalPower
controlled_by: Component -> CommandDataHandling
observed_by: Spacecraft -> Telemetry
has_evidence: Entity -> Evidence
precedes: MissionPhase -> MissionPhase

05. TYPE AND INTEGRITY CONSTRAINTS
rule C01: every Spacecraft has exactly one persistent id.
rule C02: mass_kg >= 0 whenever mass is known.
rule C03: crew_capacity >= 0.
rule C04: payload_capacity_kg >= 0 whenever known.
rule C05: 0 <= Evidence.confidence <= 1.
rule C06: Orbit requires reference_body, epoch and reference frame for interpretation.
rule C07: do not infer a circular orbit from missing eccentricity.
rule C08: UNKNOWN health is not equivalent to FAILED health.
rule C09: missing evidence is not evidence of absence.
rule C10: subsystem membership may be time-dependent and versioned.

06. MISSION LIFECYCLE
flow MissionLifecycle(spacecraft: Spacecraft, event: Event) -> Spacecraft {
  validate(event.authorised, event.timestamp, event.provenance)
  next = transition(spacecraft.operational_state, event.kind)
  require permitted_transition(spacecraft.operational_state, next)
  emit versioned_state(spacecraft.id, next, event.timestamp)
}
permitted examples:
  DESIGN -> ASSEMBLY -> TEST -> LAUNCHED -> COMMISSIONING -> ACTIVE
  ACTIVE -> SAFE_MODE -> ACTIVE
  ACTIVE -> INACTIVE -> DISPOSED
  ACTIVE -> LOST
NOTE: Mission-specific transitions and terminal outcomes require separate policies.

07. PROPULSION AND MANOEUVRE FLOW
flow PlanManoeuvre(vehicle: Spacecraft, desired_state: StateVector) -> ManoeuvrePlan {
  initial = latest_validated_state(vehicle)
  constraints = collect_constraints(vehicle, propellant, thermal, pointing, safety)
  candidate = optimise_delta_v(initial, desired_state, constraints)
  return validate_plan(candidate, dynamics_model, uncertainty, authority)
}
physics: delta_v = integral(acceleration_due_to_thrust, time)
rocket_equation: delta_v = Isp * g0 * ln(initial_mass / final_mass)
conditions: idealised equation; positive masses; Isp in seconds; g0 in m/s^2.

08. ORBITAL DYNAMICS
state_vector = (position_m[3], velocity_m_s[3], epoch, reference_frame)
for two-body approximation: acceleration = -mu * r_vector / |r_vector|^3
specific_orbital_energy = |velocity|^2 / 2 - mu / |position|
semimajor_axis = -mu / (2 * specific_orbital_energy) when bound Keplerian orbit
NOTE: Perturbations, third bodies, atmospheric drag and relativity may require richer models.

09. ATTITUDE CONTROL
flow AttitudeControl(target_orientation, observed_orientation, angular_rate) {
  error = quaternion_difference(target_orientation, observed_orientation)
  control_torque = controller(error, angular_rate)
  require actuator_limits(control_torque)
  emit authorised_actuator_command(control_torque)
}
inputs: star_tracker, inertial_sensor, sun_sensor, horizon_sensor
actuators: reaction_wheel, control_moment_gyro, magnetic_torquer, thruster

10. POWER MANAGEMENT
flow PowerBalance(spacecraft, interval) -> PowerAssessment {
  generation = integrate(validated_generation_W, interval)
  demand = integrate(validated_consumption_W, interval)
  net_energy_J = generation - demand
  return assess_battery_state(net_energy_J, capacity, efficiency, safety_limits)
}
constraints: state_of_charge in [0,1]; load shedding must preserve critical systems.

11. THERMAL MANAGEMENT
flow ThermalAssessment(temperatures, heat_inputs, heat_rejection) {
  predicted = thermal_model(temperatures, heat_inputs, heat_rejection)
  classify(predicted, subsystem_temperature_limits)
  emit risk_assessment_with_uncertainty
}

12. COMMUNICATIONS AND DATA HANDLING
flow Downlink(telemetry, link) {
  require spacecraft_identity_verified && link_available
  packet = encode_with_integrity_checks(telemetry)
  transmit(packet, link)
  verify_receipt_or_record_gap(packet)
}
flow Uplink(command, authority) {
  require authenticate(authority) && authorise(command, authority)
  require safety_interlocks(command) && anti_replay_check(command)
  transmit(command)
  verify_acknowledgement_and_execution_separately
}

13. NAVIGATION AND STATE ESTIMATION
flow EstimateState(observations: Set<Measurement>, prior: StateEstimate) -> StateEstimate {
  validated = reject_invalid_and_out_of_epoch(observations)
  estimate = filter(prior, validated, dynamics_model)
  return estimate_with_covariance_and_provenance(estimate)
}
NOTE: State estimates are probabilistic; never conflate an estimate with direct observation.

14. FAULT DETECTION, ISOLATION AND RECOVERY
flow FDIR(telemetry: TimeSeries<Telemetry>) -> RecoveryDecision {
  anomalies = detect_against_contextual_thresholds(telemetry)
  hypotheses = diagnose(anomalies, subsystem_dependency_graph)
  action = select_safe_recovery(hypotheses, operational_policy)
  require authorised(action)
  log(hypotheses, evidence, action)
}
rule: critical fault may trigger SAFE_MODE, subject to mission-specific policy.

15. PAYLOAD OPERATIONS
flow ExecuteObservation(request: ObservationRequest) -> ObservationRecord {
  require mission_authorisation(request)
  require pointing_power_thermal_storage_constraints(request)
  acquisition = collect_payload_data(request)
  return attach_time_location_calibration_provenance(acquisition)
}

16. SEMANTIC INFERENCE
rule R01: Satellite(x) -> Spacecraft(x).
rule R02: SpaceProbe(x) -> Spacecraft(x).
rule R03: CrewedSpacecraft(x) -> Spacecraft(x).
rule R04: Lander(x) -> Spacecraft(x).
rule R05: has_subsystem(x,s) AND part_of(c,s) -> indirect_part_of(c,x).
rule R06: operational_state(x,SAFE_MODE) -> requires_operational_review(x).
rule R07: health(s,FAILED) AND critical_to(s,m) -> mission_risk(m,HIGH) [defeasible].
rule R08: has_evidence(x,e) AND confidence(e,c) -> evidence_weight(x,e,c).
rule R09: orbits(x,b) -> operates_near(x,b) [context-dependent].
rule R10: communicates_with(a,b) does NOT imply communicates_with(b,a).

17. SEMANTIC EQUIVALENCE
SEMANTIC_EQUIVALENCE {
  "space vehicle" ~ "spacecraft" when referring to an engineered space-operating vehicle;
  "space probe" ~ "robotic exploration spacecraft" only with mission-context validation;
  "satellite" != "spacecraft" as universal synonyms: satellite is a subclass;
  "rocket" != "spacecraft" universally: launch vehicles and spacecraft may overlap by design;
  "orbiter" != "lander"; "telemetry" != "command";
  preserve original labels and source-qualified mappings;
}

18. CONFIDENCE AND UNCERTAINTY
CONFIDENCE {
  each asserted claim: score in [0,1]; method; provenance; assessed_at;
  distinguish sensor uncertainty, model uncertainty, and source reliability;
  combine evidence only with stated dependence assumptions;
  do not interpret confidence as guaranteed truth;
  unverified_claims: flagged, not silently promoted;
}

19. PROVENANCE AND TEMPORAL MODEL
EvidenceRecord = { claim_id, source, source_timestamp, ingestion_timestamp,
                   validity_interval, method, confidence, revision }
rule: historical claims remain addressable after corrections.
rule: conflicting sources create a conflict record pending adjudication.
rule: epoch-sensitive measurements require a reference frame and time scale.

20. FLOW_HASH
FLOW_HASH {
  canonicalise: ontology_version, entity_ids, typed_relations, rule_ids, parameters;
  exclude: volatile display formatting and transport metadata;
  digest: SHA-256(canonical_UTF8_representation);
  purpose: integrity, reproducibility, change detection;
  limitation: cryptographic hash does not prove semantic correctness;
}

21. UPDATE_MODEL
UPDATE_MODEL {
  receive proposed_change with evidence and author;
  validate schema, units, type constraints, temporal coherence;
  compare against existing assertions and detect conflicts;
  compute semantic_diff and affected_dependency_subgraph;
  require review for safety-critical or ontology-breaking changes;
  publish new immutable version and update FLOW_HASH;
  retain rollback pointer and audit trail;
}

22. AI_CONSUMPTION
AI_CONSUMPTION {
  expose: entity_types, predicates, definitions, constraints, provenance,
          temporal_validity, confidence, inference_rules, version, FLOW_HASH;
  retrieval: typed graph traversal with source and date filters;
  reasoning: distinguish entailed, inferred, hypothesised, and unknown;
  output: claim + supporting evidence + uncertainty + model_version;
  guardrails: no invented telemetry, no unverified manoeuvre commands;
}

23. VALIDATION EXAMPLES
example A:
  object: spacecraft:example_orbiter
  type: Satellite
  operational_state: ACTIVE
  orbit: orbit:example_earth_orbit
  inferred: Spacecraft(spacecraft:example_orbiter)
example B:
  object: subsystem:example_battery
  health: UNKNOWN
  inferred: NOT_ENOUGH_EVIDENCE_FOR_FAILURE
example C:
  object: command:example_attitude_adjustment
  authorisation: MISSING
  decision: REJECT_COMMAND
NOTE: Examples are synthetic; no real mission facts are asserted.

24. QUALITY ASSURANCE AND COMPLETION
checks:
  [x] typed entities and subtypes
  [x] typed relationships and integrity constraints
  [x] lifecycle, navigation, power, thermal, communications and safety flows
  [x] inference and semantic equivalence
  [x] confidence, provenance, temporal history
  [x] FLOW_HASH, UPDATE_MODEL, AI_CONSUMPTION
  [x] synthetic validation examples
status: complete conceptual Flow Algebra; not flight-certified executable software.
END FLOW ALGEBRA