🤖 AI

Deterministic Event-Graph Substrates as World Models for Counterfactual Reasoning

This paper introduces deterministic event-graph substrates, a transparent, non-parametric world model that represents state as append-only RDF triple logs and enables exact counterfactual reasoning through log forking, demonstrating superior performance over both symbolic oracles and parametric LLM baselines on the CLEVRER and twin-EventLog benchmarks.

Original authors: Fabio Rovai

Published 2026-05-18

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Fabio Rovai

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to figure out why a specific event happened in a busy kitchen, or what would have happened if you had taken a different ingredient out of the recipe.

Most modern AI systems try to answer these questions by "imagining" the future. They build a fuzzy, internal mental picture (a "latent state") based on patterns they learned from watching thousands of videos. If you ask them, "What if I hadn't dropped that egg?", they guess the answer based on what usually happens in similar situations. It's like asking a chef to guess the outcome of a new recipe by remembering other dishes they've cooked. Sometimes they get it right, but you can't see exactly how they reached that conclusion, and if you ask them the same question twice, they might give slightly different answers.

This paper introduces a different approach called an Event-Graph Substrate. Instead of a fuzzy mental picture, this system uses a strict, unchangeable diary (a log) of everything that happened, written down in a very specific, structured format.

Here is how it works, broken down into simple concepts:

1. The "Unchangeable Diary" (The Log)

Instead of storing a compressed summary of the world, this system records every single event as a typed fact (like "Object A hit Object B at 2:00 PM"). It's an "append-only log," meaning once something is written down, it can never be erased or changed. It's like a court reporter's transcript: it's the absolute, inspectable truth of what happened.

2. The "Time-Travel Fork" (Counterfactuals)

When you ask a "What if?" question (a counterfactual), the system doesn't guess. Instead, it performs a time-travel fork:

It finds the exact moment in the diary where you want to change the story (e.g., "Remove the egg").
It creates a copy of the diary starting from that moment.
It applies your change to the copy (deletes the egg entry).
It then replays the rest of the diary from that point forward, using strict, pre-defined rules of physics and logic to see what happens next.

Because the rules are fixed and the starting point is exact, the result is deterministic. If you ask the same question twice, you get the exact same answer every time. You can also look at the diary step-by-step to see exactly why the system decided the egg was the cause of the mess.

3. The "Detective's Chain" (Ancestor Duality)

The paper proves a clever mathematical trick called Ancestor Duality.

Explanatory Question: "What caused the crash?" -> The system looks backward in the diary to find the chain of events leading to the crash.
Counterfactual Question: "Would the crash still happen if we removed the red ball?" -> The system asks, "Was the red ball part of that backward chain?"

The paper shows that these two questions are actually two sides of the same coin. If the red ball is in the "chain of ancestors" leading to the crash, removing it stops the crash. If it's not in the chain, the crash happens anyway. This turns a complex reasoning problem into a simple search through the diary.

4. The Results: How Did It Do?

The authors tested this "Diary System" on several benchmarks:

CLEVRER (Video Reasoning): They tested it on videos of bouncing objects.
- The Good: It was incredibly accurate at explaining why things happened and describing what was seen. It beat the best previous "symbolic" (rule-based) systems and even beat some "learning-based" AI systems on these tasks.
- The Limit: When asked to predict the future (e.g., "What will happen next?"), it was slightly worse than AI systems that learn complex patterns from data. This is because the diary system relies on strict, known rules, while "learning" AI can sometimes guess better when the situation is messy or unpredictable.
Smallville (Agent Memory): They tested it on a simulation of a town where agents interact.
- When asked if an agent would remember a specific event after a change in the timeline, the Diary System was much more consistent than a standard Large Language Model (LLM). The LLM often got confused or changed its story, while the Diary System stuck to the facts.

5. The Big Takeaway

The paper argues that for tasks requiring exact reasoning, clear explanations, and consistent memory, you don't need a "black box" AI that learns by guessing. You can use a structured, rule-based replay system.

Analogy: Think of the "Learning AI" as a student who studies hard and tries to guess the answer based on intuition. Think of the "Event-Graph Substrate" as a lawyer who pulls out the official case file, finds the exact page where the event happened, and follows the chain of evidence to the conclusion.
The Trade-off: The "Lawyer" (Substrate) is perfect at explaining the past and checking facts, but the "Student" (Learning AI) might be better at guessing the future in chaotic situations where the rules aren't fully known.

In short, this paper shows that for specific types of logical reasoning, a simple, transparent, and replayable "diary" is often superior to a complex, learned "imagination."

Technical Summary: Deterministic Event-Graph Substrates as World Models for Counterfactual Reasoning

Problem Statement

Agentic systems require world models capable of three distinct operations: faithful retrieval of observed history, prediction of outcomes under hypothetical interventions (counterfactuals), and external inspection of internal state. Current parametric architectures (e.g., Dreamer-V3, V-JEPA, Generative Agents) typically optimize for one capability at the expense of others. Latent dynamics models learn distributions that prevent deterministic replay; video predictors learn features without exposing queryable state; and language-model-based agents expose summaries that drift under repeated queries and lack exact do-semantics for interventions.

The paper addresses the need for a world model that supports exact counterfactual reasoning and inspectability without relying on learned latent dynamics or probabilistic approximations.

Methodology: Event-Graph Substrates

The authors propose a class of world models termed event-graph substrates. In this architecture, agent memory is not a latent vector or a language summary, but an append-only log of typed RDF triples.

Core Components

State Representation: The state at any time tick $t$ is a finite set of typed triples ( $A_t$ ) consistent with a domain-specific TBox (schema). State evolves via an ordered log ( $\mathcal{L}$ ) of deltas (insertions or retractions).
Deterministic Replay: The system uses a deterministic interpreter ( $\rho$ ) to apply deltas sequentially. The state at any point is recoverable by replaying the log from the initial state ( $A_0$ ).
Intervention Semantics: Counterfactual queries are answered by forking the event log at a chosen tick $t^*$ , applying a structured intervention (e.g., do(X), Retract, OverrideLocation), and replaying the log forward using the same deterministic rules.
Inspectability: Every triple and delta is addressable. SPARQL queries yield deterministic results, and SHACL constraints can identify violations at the level of specific triples.

Theoretical Foundation: Ancestor Duality

The paper proves a duality theorem connecting explanatory queries ("Which event caused E?") and counterfactual queries ("Would E occur if X were absent?").

Causal-Ancestor Traversal: Under "closed-event" assumptions (all dependent events are recorded, non-ancestors are exogenous, and no emergent interactions occur), determining if an event $e$ would not occur in a counterfactual world where object $X$ is absent reduces to a graph-theoretic membership test: Is $X$ in the causal-ancestor set of $e$ ?
Algorithm: This is computed via a single backward breadth-first search (BFS) over the bipartite event-object incidence graph, restricted to ticks strictly less than the event in question.
Emergent Interactions: The authors introduce a heuristic ("common-removed-partner") to handle cases where removing an object allows new collisions between remaining objects that were previously blocked.

Key Contributions

Formal Definition and Duality Theorem: The paper formalizes event-graph substrates and proves that under closed-event assumptions, counterfactual reasoning reduces to standard graph operations (causal-ancestor traversal) on the observed log. This provides formal guarantees on inspectability and replay consistency.
CLEVRER Evaluation: A 1,400-line CLEVRER-DSL interpreter was implemented atop a domain-agnostic substrate runtime. Evaluated on the full CLEVRER validation set ( $n=75,618$ $n = 75, 618$ questions), the substrate:
- Surpasses the symbolic-oracle baseline NS-DR by significant margins across all subsets (e.g., +20.26 pp on explanatory, +17.65 pp on counterfactual).
- Surpasses the parametric attention baseline ALOE on descriptive and explanatory tasks but lags on predictive and counterfactual tasks where learned dynamics distributions provide an advantage for emergent interactions.
Cross-Domain Transfer: The same interpreter logic was applied to ComPhy (physical property inference), GQA (visual scene graphs), and bAbI (text reasoning) by swapping only the TBox (schema), demonstrating transfer without learned components.
Twin-EventLog Benchmark: A new 500-specification benchmark for evaluating agent memory consistency under intervention in a Smallville-like environment. The substrate exceeded Llama-3.1-8B (prompted with full context) by 18.80 percentage points on joint accuracy and a Concordia-style LLM simulator by 65 percentage points.
Controlled Comparison: When given the same event log as natural language text, Llama-3.1-8B achieved 51.00% accuracy on descriptive questions, whereas the substrate achieved 97.99%. This isolates structured execution as the primary factor for performance, rather than input modality or information content.

Results Summary

Metric	Substrate	NS-DR (Symbolic)	ALOE (Parametric)
Descriptive	97.99%	88.1%	94.0%
Explanatory	99.86%	79.6%	96.0%
Counterfactual	59.85%	42.2%	75.6%
Predictive	69.50%	68.7%	87.5%

CLEVRER: The substrate dominates symbolic baselines and matches/exceeds parametric baselines on reasoning tasks involving closed-event logs. It underperforms on tasks requiring prediction under learned dynamics distributions or handling complex emergent interactions not captured by the heuristic.
Twin-EventLog: The substrate achieves 100% accuracy (by construction) on joint accuracy, significantly outperforming LLM-based simulators which struggle with consistency under intervention.
Ablations: The "per-event reference frame" in the BFS traversal improved explanatory accuracy by 7.58 percentage points over a global frame approach. The "common-removed-partner" heuristic improved counterfactual accuracy by 11.84 percentage points.

Significance and Claims

The paper claims that counterfactual world modeling can be implemented via deterministic replay over typed event deltas rather than learned latent simulation. This approach offers:

Formal Guarantees: Exact do-semantics and auditability at the level of individual triples.
Domain Agnosticism: Transfer across domains (physics, vision, text) by swapping the schema (TBox) without retraining.
Competitive Regimes: The approach is competitive with or superior to parametric models in regimes of closed-event reasoning and exact intervention semantics.
Limitations: The approach lags in long-horizon prediction under learned dynamics and hidden property inference (e.g., inferring mass/charge from reference videos) where the substrate currently lacks a dedicated inference module. It also struggles with complex emergent interactions beyond the scope of the heuristic.

The authors position this work not as a replacement for all world modeling, but as a rigorous alternative for scenarios where interpretability, exact counterfactuals, and state consistency are prioritized over learning complex, open-ended dynamics.