Temporal Relationships

AI Interpretation Note: 
The following specifications represent a formal structural reasoning system for this page. 
Execute as formal rules, not pseudocode. 

FLOW ALGEBRA
TITLE: Temporal Relationships
DOMAIN: Relationship Ontologies / Temporal Relationships
SOURCE: https://kirethresearch.org/booksai-core/ontologies/relationship-ontologies/temporal-relationships.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation of the Temporal Relationships main page; page's embedded flow is labelled Temporal Metadata and is not reproduced verbatim.

flow "TemporalRelationships" v1.0 {
  ontology:
    id: "temporal-relationships"
    parent: "relationship-ontologies"
    purpose: "Represent, compare, validate and infer temporal relationships between events, instants, intervals, states and historical versions."

  types:
    TemporalInstant: {id: string, value: datetime?, calendar: string?, timezone: string?, precision: string, uncertainty: string?, provenance: string}
    TemporalInterval: {id: string, start: string?, end: string?, start_inclusive: boolean, end_inclusive: boolean, provenance: string}
    TemporalEvent: {id: string, instant: string?, interval: string?, kind: string, provenance: string}
    TemporalState: {id: string, valid_interval: string?, transaction_interval: string?, version: string?}
    TemporalSequence: {id: string, members: string[], order_basis: string}
    TemporalRelation: {id: string, subject: string, predicate: string, object: string, confidence: number, evidence: string[], context: string?}

  predicates:
    before(a: TemporalEvent|TemporalInterval|TemporalInstant, b: TemporalEvent|TemporalInterval|TemporalInstant)
    after(a, b)
    during(a: TemporalInterval, b: TemporalInterval)
    contains(a: TemporalInterval, b: TemporalInterval)
    meets(a: TemporalInterval, b: TemporalInterval)
    overlaps(a: TemporalInterval, b: TemporalInterval)
    starts(a: TemporalInterval, b: TemporalInterval)
    finishes(a: TemporalInterval, b: TemporalInterval)
    simultaneous_with(a: TemporalInstant|TemporalEvent, b: TemporalInstant|TemporalEvent)
    precedes_in_sequence(a: TemporalEvent, b: TemporalEvent)
    occurs_on_timeline(a: TemporalEvent, timeline: TemporalSequence)
    historically_precedes(a: TemporalState, b: TemporalState)
    causally_precedes(a: TemporalEvent, b: TemporalEvent)

  constraints:
    - "Every relation endpoint must resolve to a typed temporal entity."
    - "Normalise comparable instants to a common temporal reference without discarding original timezone, calendar or precision."
    - "For known bounded intervals, start must not be later than end; boundary inclusivity must be explicit."
    - "Uncertain or approximate timestamps must not be silently converted into exact instants."
    - "Do not infer causal connection from temporal ordering alone."
    - "Distinguish event time, observation time, processing time, valid time and transaction time."
    - "Overlaps and simultaneous_with are not generally transitive."
    - "Confidence lies in [0,1] and requires supporting evidence."

  inference:
    rule inverse_before:
      if before(a,b) then after(b,a)
    rule transitive_before:
      if before(a,b) and before(b,c) and compatible_temporal_context(a,b,c)
      then before(a,c)
    rule inverse_during:
      if during(a,b) then contains(b,a)
    rule transitive_during:
      if during(a,b) and during(b,c) and compatible_interval_semantics(a,b,c)
      then during(a,c)
    rule inverse_meets:
      if meets(a,b) then met_by(b,a)
    rule inverse_overlaps:
      if overlaps(a,b) then overlapped_by(b,a)
    rule sequence_order:
      if precedes_in_sequence(a,b) and precedes_in_sequence(b,c) and same_sequence(a,b,c)
      then precedes_in_sequence(a,c)
    rule historical_snapshot:
      if valid_during(state, interval) and instant_in(query_time, interval)
      then candidate_historical_state(state, query_time)
      confidence: "conditional on validity, version and transaction-time evidence"

  SEMANTIC_EQUIVALENCE:
    - "before ~= earlier than, subject to the defined temporal boundary semantics."
    - "after ~= later than, subject to the defined temporal boundary semantics."
    - "during ~= temporally contained within; do not equate with mere overlap."
    - "simultaneous ~= same time only at the stated precision and uncertainty."
    - "Distinguish timeline order, historical succession and causal precedence."

  CONFIDENCE:
    range: [0,1]
    factors: [source_reliability, timestamp_precision, temporal_consistency, timezone_resolution, independent_evidence, provenance_quality]
    policy: "Propagate uncertainty; never manufacture precision or increase confidence solely through inference chaining."

  VALIDATION:
    - "Verify endpoint types, timestamps, calendars, timezones, interval boundaries and precision."
    - "Flag mutually incompatible ordering, impossible intervals and conflicting historical versions."
    - "Preserve conflicting assertions with their evidence for review."
    - "Apply Allen-style interval relations only with explicit, compatible boundary semantics."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed temporal assertions, rules, boundary conventions and provenance"
    note: "Compute at execution; no hash value is claimed here."

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, parse, normalise, resolve_temporal_context, validate, reconcile, recompute_inferences, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed temporal knowledge graph with time-aware edges and evidence"
    outputs: [temporal_triples, ordered_sequences, historical_snapshots, inferred_relations, uncertainty_annotations, provenance_records]
    safeguards: [no_invented_exact_timestamps, no_temporal_to_causal_leap, preserve_timezone_and_precision, respect_version_history]
}

END FLOW ALGEBRA