P202 — AIEP — Temporal Event Graph

Applicant: Neil Grassby Classification: Patent Application — Confidential Priority: Claims priority from GB2519711.2 filed 20 November 2025 Architecture Layer: AIEP AGI Cognition Layer — Phase 2 Dependencies: P200 — CWSG, P201 — Entity State Registry

Framework Context

[0001] This specification operates within an Architected Instruction and Evidence Protocol (AIEP) environment as defined in United Kingdom patent application GB2519711.2 and GB2519798.9, filed 20 November 2025.

[0002] The present specification defines the temporal event ordering and timeline representation layer of the Phase-2 AIEP architecture, providing a deterministic temporal substrate for causal reasoning over sequences of events derived from evidence artefacts.

Field of the Invention

[0003] The present invention relates to artificial intelligence reasoning systems, knowledge representation architectures, and temporal event modelling.

[0004] More particularly, the invention relates to the construction and maintenance of a deterministic temporal event graph derived from evidence artefacts, wherein events are ordered by evidence-bound timestamps and connected by successor edges representing temporal progression.

Background

[0005] Causal reasoning over sequences of real-world events requires a persistent temporal ordering of events that is grounded in evidence provenance. Conventional systems timestamp events using wall-clock time without binding timestamps to evidence, introducing the possibility of temporal inconsistency during replay.

[0006] Temporal reasoning systems must distinguish between: the time at which an event occurred in the world; the time at which evidence of the event was published; and the time at which the evidence was admitted to the local ledger. Conflating these three timestamps introduces non-reproducibility.

[0007] Without a canonical evidence-bound temporal event graph, reasoning systems cannot deterministically reconstruct the sequence of real-world events leading to a specified state, and cannot evaluate counterfactual scenarios beginning from a precisely defined temporal position.

Summary of the Invention

[0008] The invention provides a Temporal Event Graph (TEG) in which each event node is derived from an evidence artefact and carries a multi-timestamp record distinguishing world time, publication time, and admission time.

[0009] Events are connected by temporal successor edges forming a directed acyclic graph over the time dimension. Causal edges from the CWSG (P200) may be overlaid on the temporal structure to produce a combined causal-temporal model.

[0010] The TEG supports: deterministic timeline queries by world time, publication time, or admission time; event chain reconstruction for specified entity trajectories; temporal gap detection where evidence coverage is absent; and counterfactual insertion points at any temporal position.

ASCII Architecture

Evidence Artefact (with timestamps)
          |
          v
+----------------------------+
| Event Extraction Layer     |
+-------------+--------------+
              |
              v
+---------------------------------------------------+
|           Temporal Event Graph (TEG)              |
|                                                   |
|  [Event_t1] --successor--> [Event_t2]             |
|      |                          |                 |
|  world_time                world_time             |
|  pub_time                  pub_time               |
|  admission_time            admission_time         |
|  evidence_hash             evidence_hash          |
+---------------------------------------------------+
              |
              v
     Causal World State Graph (P200)
     + Counterfactual Engine (P203)

Definitions

[0011] Temporal Event Graph (TEG): A directed acyclic graph in which each node represents a discrete real-world event derived from an evidence artefact, and each edge represents temporal succession or causal dependency between events.

[0012] EventNode: A node in the TEG representing a discrete real-world occurrence. Each EventNode carries a multi-timestamp record, a provenance hash, an entity reference set, and a structured event descriptor.

[0013] MultiTimestampRecord: The three-level timestamp structure of an EventNode comprising: world_time (the time at which the event occurred in the world, as reported in the evidence artefact); pub_time (the time at which the evidence artefact was published); and admission_time (the time at which the evidence artefact was admitted to the local ledger).

[0014] SuccessorEdge: A directed edge in the TEG from EventNode A to EventNode B indicating that A temporally precedes B. Successor edges are derived from the sequential ordering of world times in the underlying evidence artefacts.

[0015] TemporalGapRecord: A marker record inserted into the TEG between two EventNodes whose world_time interval exceeds a configurable gap threshold, indicating that evidence coverage is absent for that interval.

[0016] EventChainQuery: A query specifying an entity, a start time, and an end time, returning the ordered sequence of EventNodes referencing that entity within the time bounds.

Detailed Description

[0017] Event Extraction. When an evidence artefact is admitted to the AIEP evidence ledger, the Event Extraction Layer parses the artefact content to identify discrete real-world occurrences. An occurrence is identified by: the presence of a named entity in an active state; a verb phrase indicating a discrete action or transition; and an associated timestamp expression. For each identified occurrence, an EventNode is created.

[0018] MultiTimestamp Assignment. EventNode timestamps are assigned as follows. The world_time field is populated from the temporal expression parsed from the evidence artefact content. Where multiple temporal expressions are present, the most specific expression taking precedence. The pub_time field is populated from the evidence artefact publication date. The admission_time field is populated from the AIEP ledger admission record timestamp.

[0019] SuccessorEdge Construction. After EventNode creation, the TEG insertion procedure evaluates the new node’s world_time against existing nodes in the TEG. For each existing EventNode with a world_time earlier than the new node’s world_time and sharing at least one common entity reference, a SuccessorEdge candidate is proposed. SuccessorEdge proposals are accepted when the entity reference overlap satisfies a configurable minimum overlap threshold, preventing spurious temporal connections between unrelated events.

[0020] Temporal Gap Detection. After each batch of EventNode insertions, the TEG evaluator scans the successor-edge sequences of all active entity chains. When the world_time interval between consecutive EventNodes in an entity chain exceeds the configurable temporal gap threshold, a TemporalGapRecord is inserted between the two EventNodes. TemporalGapRecords are propagated to reasoning consumers to signal that inference over the gap period is based on incomplete evidence coverage.

[0021] CWSG Overlay. The TEG co-exists with the Causal World State Graph (P200). TEG EventNodes reference CWSG entity nodes via the same entity identifier scheme defined in the Entity State Registry (P201). Causal edges from the CWSG may be overlaid on the TEG to produce a combined causal-temporal model in which each event is positioned both temporally and in the causal dependency graph.

[0022] Counterfactual Insertion Points. The TEG exposes a counterfactual insertion point interface for the Counterfactual Timeline Engine (P203). An insertion point is defined by a world_time value and an optional entity filter. The insertion point record includes the immediate predecessor EventNodes and successor EventNodes at the specified temporal position, together with the active entity states at that position, enabling the CTE to branch the timeline precisely.

[0023] EventChainQuery Interface. The TEG exposes an EventChainQuery interface: query_chain(entity_id, start_time, end_time, timestamp_type) returning an ordered list of EventNodes referencing the specified entity within the time bounds. The timestamp_type parameter selects which timestamp dimension (world_time, pub_time, or admission_time) is used for range filtering, enabling comparison of world-time-ordered versus admission-ordered views of the same entity history.

[0024] Deterministic Replay. The TEG supports complete deterministic reconstruction from the ordered sequence of evidence artefact admissions. Replaying the TEG mutation log up to a specified admission timestamp produces an identical TEG state to that which existed at that admission time.

Technical Effect

[0025] The invention provides a deterministic, evidence-bound temporal ordering of real-world events that preserves provenance at the multi-timestamp level, preventing conflation of world time, publication time, and ledger admission time. By maintaining SuccessorEdges derived from evidence-grounded world times, the TEG enables reproducible timeline reconstruction and temporal gap detection that are not achievable with wall-clock-timestamped event stores. This temporal substrate underpins counterfactual reasoning (P203) and hypothesis simulation (P204) with a precisely defined branching point semantics.

Claims

1. A computer-implemented method for constructing and maintaining an evidence-bound temporal event graph for deterministic reasoning systems, the method comprising:

   (a) extracting discrete event occurrences from evidence artefacts admitted to an evidence ledger;

   (b) assigning each extracted event a multi-timestamp record comprising a world time derived from the evidence artefact content, a publication time derived from the artefact publication date, and an admission time derived from the ledger admission record;

   (c) constructing directed successor edges between event nodes sharing common entity references based on their world time ordering;

   (d) detecting temporal gaps in entity-specific event chains where the world time interval between consecutive event nodes for the same entity exceeds a configurable threshold, and inserting temporal gap records at detected gap positions; and

   (e) recording each mutation to the temporal event graph in an append-only mutation log, enabling deterministic replay of the temporal event graph state at any prior admission timestamp.

2. The method of claim 1, wherein the world time field of the multi-timestamp record is populated from the most specific temporal expression parseable from the evidence artefact content.

3. The method of claim 1, wherein successor edge construction applies a configurable minimum entity reference overlap threshold, preventing temporal connections between events sharing fewer than the threshold number of common entity references.

4. The method of claim 1, wherein the method further comprises overlaying causal dependency edges from a causal world state graph onto the temporal event graph structure, producing a combined causal-temporal model.

5. The method of claim 1, wherein the method further comprises exposing a counterfactual insertion point interface that returns, for a specified world time, the immediate predecessor event nodes, successor event nodes, and active entity states at that temporal position.

6. The method of claim 1, wherein the method further comprises an event chain query interface accepting an entity identifier, a start time, an end time, and a timestamp type parameter, returning an ordered event sequence filtered on the selected timestamp dimension.

7. The method of claim 6, wherein the timestamp type parameter is selectable from world time, publication time, or admission time, enabling comparison of world-time-ordered and admission-ordered views of entity history.

8. A temporal event graph system for an evidence-bound reasoning architecture, comprising one or more processors and a persistent event store, wherein each event node in the graph carries a multi-timestamp record binding the node to the evidence artefact from which it was derived.

9. The system of claim 8, wherein temporal gap records are inserted between event nodes in an entity chain when the world time interval between consecutive nodes exceeds a configured gap threshold.

10. A non-transitory computer-readable medium storing instructions which, when executed by one or more processors, perform the method of any of claims 1 to 7.

Abstract

A computer-implemented temporal event graph is disclosed for evidence-bound AI reasoning architectures. Discrete events are extracted from admitted evidence artefacts and represented as event nodes carrying a three-level timestamp record distinguishing world time, publication time, and ledger admission time. Directed successor edges connect temporally ordered events sharing common entity references. Temporal gap records are inserted between event nodes in an entity chain wherever the world time interval exceeds a configurable threshold, signalling incomplete evidence coverage. The graph supports counterfactual insertion point queries, entity chain queries filterable by timestamp dimension, and causal edge overlay from a co-resident causal world state graph. Deterministic replay of the temporal event graph is supported through an append-only mutation log. | admission_time admission_time | | evidence_hash evidence_hash | +---------------------------------------------------+ | v Timeline Query Engine (P219)

---

## Detailed Description

[0011] **Event Node Structure.** Each event node in the TEG contains: `event_id` (SHA-256 of entity_id + event_type + world_time + evidence_hash); `entity_ids` (array of entity identifiers involved); `event_type` (classified event category); `world_time` (ISO 8601 timestamp extracted from evidence content — the time the event occurred); `published_at` (ISO 8601 timestamp from evidence artefact publication date); `admitted_at` (ISO 8601 timestamp of AIEP ledger admission); `evidence_hash` (content hash of source evidence artefact); and `description` (extracted event summary string).

[0012] **Three-Timestamp Model.** The distinction between world_time, published_at, and admitted_at is architecturally significant. World_time enables reasoning about the actual temporal sequence of events. Published_at enables reasoning about information latency. Admitted_at enables deterministic replay of the graph from the perspective of any point in the admission history.

[0013] **Successor Edge Construction.** When a new event node is inserted into the TEG, the system identifies all existing events involving the same entity identifiers and inserts a successor edge from the closest preceding event to the new event, ordered by world_time. This produces a per-entity temporal chain.

[0014] **Cross-Entity Temporal Alignment.** The TEG also maintains a global temporal ordering across all events, enabling queries such as "all events occurring between timestamp T1 and T2 across all entities".

[0015] **Temporal Gap Detection.** The TEG identifies temporal gaps — periods in the world_time dimension for which no evidence artefacts exist for a specified entity. Gap records are produced by the gap detection subsystem and stored as gap nodes in the TEG, enabling reasoning systems to identify areas of evidential absence.

[0016] **Counterfactual Integration.** The TEG provides an insertion point API for the Counterfactual Timeline Engine (P203), allowing hypothetical events to be inserted into the graph at specified world_time positions without modifying the canonical event chain.

---

## Claims

1. A temporal event graph for an evidence-bound reasoning architecture wherein each event node carries three distinct timestamps: world occurrence time, publication time, and evidence admission time.
2. The system of claim 1 wherein successor edges connect temporally adjacent events for the same entity.
3. The system of claim 1 wherein the graph supports deterministic reconstruction of any prior temporal state.
4. The system of claim 1 wherein gap nodes record temporal intervals lacking evidence coverage.
5. The system of claim 1 wherein the graph exposes counterfactual insertion points at arbitrary temporal positions.
6. A method of constructing a temporal event graph from evidence artefacts comprising extracting event data, recording three-level timestamps, and inserting successor edges to form per-entity temporal chains.