Temporal Relationship Ontology

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

flow "TemporalRelationshipOntology" v1.0 {
  ontology:
    id: "temporal-relationship-ontology"
    parent: "temporal-relationships"
    purpose: "Represent, reason over and validate temporal ordering and interval relationships with explicit uncertainty and provenance."

  types:
    Instant: {id: string, timestamp: datetime, time_scale: string?, precision: string?, uncertainty: number?}
    Interval: {id: string, start: Instant?, end: Instant?, start_inclusive: boolean, end_inclusive: boolean}
    Event: {id: string, label: string, interval: Interval?, provenance: string}
    TemporalAssertion: {id: string, subject: string, predicate: string, object: string, confidence: number, evidence: string[], context: string?}

  predicates:
    before(a: Event, b: Event)
    after(a: Event, b: Event)
    meets(a: Event, b: Event)
    overlaps(a: Event, b: Event)
    during(a: Event, b: Event)
    starts(a: Event, b: Event)
    finishes(a: Event, b: Event)
    equals_interval(a: Event, b: Event)
    simultaneous(a: Event, b: Event)

  constraints:
    - "All temporal assertion endpoints must resolve to typed entities."
    - "Confidence must lie within [0,1]."
    - "Normalise timestamps to an explicit time scale and retain original offsets."
    - "Intervals must have start <= end when both endpoints are known."
    - "Distinguish strict precedence from meeting at a shared endpoint."
    - "Interval relations require consistent endpoint and inclusivity conventions."
    - "Do not infer causation from precedence or simultaneity."
    - "Do not assert definite ordering where temporal uncertainty makes the intervals ambiguous."

  inference:
    rule inverse_before:
      if before(a,b)
      then after(b,a)
      confidence: "retain original evidence and uncertainty"
    rule transitive_before:
      if before(a,b) and before(b,c) and compatible_time_scales(a,b,c)
      then before(a,c)
      confidence: "propagate evidence without increasing certainty"
    rule inverse_during:
      if during(a,b)
      then contains_interval(b,a)
      confidence: "retain context and evidence"
    rule interval_equality_symmetry:
      if equals_interval(a,b)
      then equals_interval(b,a)
      confidence: "retain source confidence"

  SEMANTIC_EQUIVALENCE:
    - "Normalise equivalent temporal relation labels only when their interval semantics match."
    - "Distinguish same event identity from coincident event times."
    - "Preserve time scales, calendars, precision and uncertainty during mapping."

  CONFIDENCE:
    range: [0,1]
    factors: [timestamp_precision, measurement_uncertainty, source_reliability, calendar_conversion, temporal_context]
    policy: "Do not increase confidence solely by chaining temporal assertions."

  VALIDATION:
    - "Check event references, interval endpoints, ordering consistency and provenance."
    - "Flag contradictory temporal assertions and unresolved time-scale conversions."
    - "Preserve indeterminate or competing interval interpretations when evidence is insufficient."

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

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

  AI_CONSUMPTION:
    representation: "typed temporal knowledge graph with evidence-backed edges"
    outputs: [temporal_triples, interval_relations, ordering_constraints, uncertainty_annotations, provenance_records]
    safeguards: [no_unsupported_causality, preserve_temporal_precision, avoid_false_ordering, retain_conflicting_evidence]
}

END FLOW ALGEBRA