Cause and Effect is a Diff, not a Chain: Why Prolog Fails Spectacularly

And how creativity gets lost in the shuffle

The Seductive Logic of Chains

If I asked you why the window broke, you’d probably say something like: “The ball broke the window because someone threw it.”

This feels right. It feels obvious. We experience time linearly, so we narrate causality linearly. A caused B caused C. Dominoes falling in sequence. GOFAI (Good Old-Fashioned AI) was built entirely on this intuition - systems like Prolog that represent the world as chains of if-then rules:

broke(Window) :- thrown(Ball), hit(Ball, Window), fragile(Window).

It’s elegant. It’s human-readable. And for simple domains, it actually works.

The problem is that reality doesn’t.

The Wall

Here’s where symbolic causal chains hit a wall so hard that entire research programs ground to a halt in the 1980s.

Let’s say you’re trying to model a simple game of chess. You write rules like:

• IF pawn_moves_forward THEN board_state_changes

• IF piece_captured THEN material_advantage_shifts

• IF king_in_checkmate THEN game_ends

Seems manageable. But now try to answer: “What happens to my winning chances if I make pawns reversible?”

To answer this with symbolic chains, you’d need to enumerate every possible game state, trace through every causal pathway that reversible pawns affect, account for how each change propagates through every future decision point, and somehow capture all the emergent second-order effects.

The combinatorial explosion is instant. The frame problem emerges: you can’t possibly specify all the things that don’t change when something changes. The context sensitivity makes every chain conditional on a thousand other chains.

This isn’t a coding challenge. It’s a fundamental limitation of representing causality as explicit symbolic chains. Complex systems have emergent properties that no amount of if-then rules anticipated because emergence is what happens between the rules.

The Hidden Assumption

The symbolic AI paradigm rests on an assumption so obvious that questioning it feels almost absurd:

To reason about causality, you must represent it symbolically.

But why?

Causality exists in the world whether or not we write it down. When you change the rules of chess, the effects on gameplay are real and complete; they happen whether or not you enumerated them in Prolog. The causal relationships are already there, encoded in the structure of the system itself.

What if we’ve been looking at causality backwards? What if you don’t need to represent causal chains at all - you just need to measure causal effects?

Causality as Geometry

Here’s a different ontology entirely.

Every system - chess, language, supply chains, immune responses - generates observable behavior when you run it. Play chess games, write sentences, track shipments, watch cellular responses. Each execution produces a sequence of states and transitions between them.

This raw observational data can be captured as a state transition graph: nodes are states, edges are observed transitions. But the graph itself isn’t the insight - it’s just the trace of what happened.

The insight comes from measuring geometric properties of that trace across multiple conceptual dimensions.

Think of measurement as happening in a multiverse of parallel analytical spaces. Each dimension is a separate universe where you measure a different structural property:

• The Temporal Dimension: How does proximity to terminal/failure states change over time?

• The Reversibility Dimension: How bidirectional are the transitions? Can you undo moves?

• The Branching Dimension: How many valid next states exist from any given state?

• The Information Dimension: How much hidden state affects available actions?

Within each dimension-universe, you have multiple axes - specific measurable curves that trace different aspects of that dimension. For example, in the Temporal Dimension:

• Loss curve axis: How suddenly can you go from winning to losing?

• Energy curve axis: How does effort required change over time?

• Momentum curve axis: How do advantages compound or dissipate?

Each axis produces a geometric curve with a specific shape. In standard chess:

• The loss curve is cliff-shaped (checkmate ends everything instantly)

• In natural language, the loss curve is gradual (mistakes don’t end conversations)

These curves are empirical facts about the system - they emerge from observed behavior, not from reading the rulebook.

Why This Is Practical (You Don’t Need to Simulate Everything)

“Chess has more possible positions than atoms in the observable universe. How can you possibly measure these curves?”

The answer: you don’t need to simulate everything. You just need to observe typical behavior.

The geometric properties we care about - the loss cliff, the reversibility signature, the branching patterns - aren’t hiding in obscure corners of the state space. They’re attractors: patterns that typical gameplay naturally converges toward regardless of where you start.

Play a dozen chess games and you’ll immediately notice:

• Games end suddenly and catastrophically (the loss cliff shows up in almost every game)

• Pawns create irreversible commitments (you see this pattern constantly)

• Hanging pieces to single attackers loses material (happens all the time)

These aren’t rare edge cases. They’re the dominant structural features of the game. And they assert themselves quickly in observed play because they’re dominant. The system is constantly being pulled toward these patterns.

An attractor is a region or pattern in state space that trajectories converge toward. When you measure curves along dimension-axes, you’re essentially mapping the attractor landscape - the stable structural features that characterize how the system typically behaves.

The practical implication: You don’t need exhaustive simulation. You need representative sampling. Play a few thousand games naturally and the prominent structural features emerge clearly in the statistics. The curves stabilize quickly because attractors assert themselves.

The important features aren’t hiding. They’re the ones pulling the system toward themselves.

Now here’s the key move: cause and effect is just the diff between two geometric fingerprints.

A fingerprint is the complete profile of a system across all dimension-universes - every curve along every axis in every dimension.

Change a rule. Re-run the system. Re-measure all the curves across all dimensions. The geometric transformation between the before-fingerprint and after-fingerprint is the complete causal relationship. All emergent effects, all context dependencies, all second-order consequences - they show up automatically in how the curves changed across the dimension-axis multiverse.

You don’t enumerate chains. You don’t predict effects symbolically. You just observe the diff across dimensions.

And because we’re measuring attractors, not exhaustive state spaces, this diff is practical to compute. The geometric transformations you’re measuring are attractor-level properties. They dominate the statistics. They show up fast in representative samples.

V. The Multiverse Structure

But there’s a subtlety here. You can’t just measure one curve along one axis and call it done. Different structural properties require fundamentally different analytical spaces.

Think of it this way: imagine each high-level property you could measure - temporal dynamics, reversibility, branching complexity, information symmetry - as a separate parallel universe. Each dimension-universe has its own geometric space containing multiple axes where you can plot different curves.

A domain like “chess” doesn’t exist in just one analytical space. It casts a “shadow” - a specific geometric signature - into every dimension-universe simultaneously:

In the Temporal Dimension:

• Loss curve axis: cliff-shaped (instant checkmate)

• Recovery time axis: zero (no comeback mechanics)

• Momentum axis: advantages compound exponentially

In the Reversibility Dimension:

• Move reversibility axis: near-zero for pawns, moderate for other pieces

• Capture reversibility axis: zero (captures are permanent)

• Commitment depth axis: high (decisions are binding)

In the Branching Dimension:

• Average branching factor axis: ~35 legal moves per position

• Decision density axis: moderate complexity

• Constraint tightness axis: increases sharply in endgames

When you change a rule - say, make pawns reversible - you don’t just get “chess changed by 47.3 units.” You get a per-dimension geometric transformation - specific curve deformations in specific analytical universes:

Reversibility Dimension transforms:

• Move reversibility axis: pawns go from unidirectional to bidirectional

• Commitment depth axis: decreases substantially

• Error recovery axis: massive increase

Temporal Dimension transforms:

• Loss curve axis: deforms from cliff to gradient (hanging a piece is no longer instantly fatal)

• Recovery time axis: increases (you can retreat and regroup)

Branching Dimension transforms:

• Endgame branching axis: increases (more viable continuations)

• Decision space axis: expands

The causality isn’t a chain. It’s a signature - a specific pattern of geometric deformations across multiple dimension-universes, along multiple axes within each dimension.

And that signature is:

1. Complete - all emergent effects are captured across all dimensions

2. Observable - just measure the curves before and after along each axis

3. Transferable - if you want this effect in another domain, look for mechanics that produce this geometric signature across these specific dimensions

Why the Multiverse Matters for Diffs

The multiverse structure isn’t mathematical decoration. It’s what makes the diff structurally interpretable.

If you squashed all properties into a single flat vector space, the diff would be meaningless. You’d get “Chess changed by 47.3 units” - which tells you nothing about what actually changed structurally.

But with parallel dimension-universes, each analytical space is isolated. The temporal loss curve and the reversibility landscape aren’t just “different axes” - they’re different kinds of measurement spaces that can’t be meaningfully compared within a single coordinate system.

The diff reveals exactly which dimension-universes were affected and how:

• This specific rule change → these specific curve deformations → along these specific axes → in these specific dimension-universes

That’s actionable. That’s transferable. That’s what lets you say “if I want this kind of effect in Domain B, I need a mechanic that produces this geometric signature across these dimensions.”

The Chess Example

Let me show you why this isn’t just abstract math. Here’s a concrete example you can verify yourself.

“Why can’t you use a transformer to predict the next chess move the way you do with language?”

The answer seemed straightforward at first - transformers work on chess, they’re just harder to train than language models.

Then came the key question: “Could you adjust the rules of chess to make it closer to natural language?”

One might think of common game design patterns. Fog of war. Piece fatigue. Time decay. All the stuff you’d find in a game design textbook.

But they are abstract principles, not actual rule changes. So this was proposed: “What if a piece can only be captured if two pieces are attacking it?”

One could instantly recognize its geometric signature:

• Creates error tolerance (hanging a piece to one attacker is recoverable)

• Softens the loss cliff (mistakes aren’t instantly fatal)

• Increases branching factor (more moves become “reasonable”)

It requires a creative leap: mapping the abstract property “error tolerance in language” to a concrete chess mechanic “require double attacks for capture.” I could verify it works because I could see the geometric transformation it would produce.

We kept going and added:

• Reversible pawns (can move backward) - fills the void in the Reversibility Universe

• Points for checks instead of checkmate (dense reward signal) - transforms the Temporal Universe’s cliff into a gradient

• Pawn resurrection (reaching the back rank resurrects a captured piece) - creates long-term context and material conservation

Each rule change produced a measurable geometric transformation. And together, they transformed chess from a game with language-model-hostile properties into one with language-model-friendly properties - without needing to enumerate a single causal chain.

We just measured the diff.

Why This Matters Beyond Chess

This isn’t about chess. Chess was just a simple, reproducible example of the principle.

The real implication is this: you can measure structural causality in any domain by observing state transitions and measuring geometric transformations.

Current LLMs struggle with causal reasoning because they’re trying to learn causal chains from text. But text contains narratives of causality (”the ball broke the window because it was thrown”), not the actual causal structure. The narratives are incomplete, context-dependent, and often wrong.

The actual causality is in the physics - the state transition graph of how systems behave. And you can measure it directly.

This suggests a completely different architecture for AI systems that need to reason about cause and effect:

1. The Measurement Engine: Takes a domain (chess, language, supply chains, biological systems), runs it to generate state transitions, builds the graph, measures geometric properties across thousands of “dimension-universes”

2. The Fingerprint: A high-dimensional signature capturing the complete topological structure of the domain across all measured properties

3. The Diff Engine: Compares fingerprints to find structural gaps, proposes mechanical changes, re-measures, verifies the transformation

4. The LLM Interface: Translates human intent into measurement queries, interprets geometric outputs back into natural language, communicates results

The LLM doesn’t do causal reasoning. It just interfaces with a tool that measures causality directly from observed behavior.

The Division of Labor

This reframes what LLMs are actually good at. Not deep reasoning from first principles, but:

• Understanding what a human is trying to achieve

• Formulating the right questions to ask the measurement tool

• Interpreting the dimensional output in context

• Communicating the structural transfers in human-meaningful terms

The reasoning that actually matters - finding the structural bridge between chess and language, identifying which mechanics create which geometric signatures - gets offloaded to a deterministic engine that physically cannot hallucinate.

It’s analogous to how a skilled analyst uses a database. The value isn’t in the analyst memorizing all the data. It’s in knowing what query to run and how to interpret the results.

What This Solves

The hallucination problem: When an LLM tries to reason through complex causality, it hallucinates because it’s guessing the next statistically likely word. In this architecture, the LLM doesn’t guess at causal relationships - it delegates to a deterministic measurement engine that observes them empirically.

The AGI requirement: People assume we need Artificial General Intelligence to solve novel problems. This architecture suggests we don’t. We just need a good linguistic interface (the LLM) plugged into a good structural measurement tool (the diff engine).

The creative leap problem: LLMs can’t make creative leaps between disparate domains because they pattern-match within their training distribution. But they can recognize structural analogies once articulated and verify geometric transformations. The measurement engine provides the structural data that makes cross-domain transfer possible.

The Meta-Causal Leap (Or: Where Brilliant Insight Actually Lives)

Here’s the most important distinction, and it’s one that every existing framework for causality completely misses.

Standard causal reasoning - whether Prolog chains, Bayesian networks, causal graphs, or any other formalism - operates within a fixed rule system. The laws of the universe are held constant and you reason about what happens inside them.

• Physics models: assume the laws of physics don’t change

• Medical causality: assume human biology is constant

• Economic models: assume market mechanisms are stable

• Chess engines: assume the rules of chess are fixed

Even the most sophisticated causal AI assumes the underlying mechanics are stable. You’re asking “what happens when X changes within these rules?”

But that’s not where brilliant insight lives.

Brilliant insight operates ON rule systems, not within them.

• Scientific revolutions: Einstein didn’t discover new facts within Newtonian physics - he changed the rules of how we model spacetime

• Artistic breakthroughs: Picasso didn’t paint better realism - he changed what painting could be

• Your chess redesign: You didn’t find better moves in standard chess - you changed what chess was

This is meta-causality: reasoning about what happens to the entire system when the rules themselves change.

And here’s why this matters: normal cause-and-effect frameworks collapse completely at this level.

Prolog can’t handle this. The if-then chains are built FROM the axioms. When you change the axioms, all the chains become meaningless. You can’t write a rule that reasons about what happens when the rules themselves change - that’s a logical type error.

Bayesian networks can’t handle this. The conditional probability tables assume a stable causal structure. Change the underlying mechanisms and every probability you carefully estimated becomes wrong.

Causal graphs can’t handle this. The edges represent stable causal relationships. When the rules change, you need an entirely new graph. There’s no formalism for “the diff between two causal graphs across different rule systems.”

But the geometric diff handles this naturally.

Because it’s purely observational, it has no dependency on the rules remaining stable. You just:

1. Measure the attractor landscape under Rule System A

2. Measure the attractor landscape under Rule System B

3. The diff across all dimension-universes IS the meta-causal relationship

The diff doesn’t care that the underlying mechanics changed. It just measures what actually happened to the system’s behavior across every conceptual dimension.

When you made pawns reversible, you didn’t reason within chess - you operated on chess. And the multiverse diff captured the complete transformation:

• Reversibility Universe: void → substantial structure

• Temporal Universe: cliff → gradient

• Branching Universe: constrained → expanded

That’s meta-causality. That’s the diff between two different physics, two different rule systems, two different possible worlds.

And it’s measurable, transferable, and complete - without requiring any stable axioms to reason from.

This is why the framework handles creative insight that other approaches can’t touch. Scientific breakthroughs, artistic innovations, paradigm shifts - these all involve changing the rules, not optimizing within them.

The geometric diff is the first framework that can measure what happens when you do that.

Why Scaling Makes AI Less Creative (Not More)

Here’s an uncomfortable observation that follows directly from the meta-causal framework:

The better an LLM gets at operating within existing rule systems, the worse it gets at operating on them.

Early language models - GPT-2, early GPT-3 - were undertrained relative to the complexity of the domains they touched. They hadn’t fully internalized any rule system. The concept boundaries in their latent space were fuzzy and porous. “Chess” and “language” bled into each other not through insight, but through incomplete knowledge.

This led to hallucinations. But it also led to accidental creativity - unexpected connections that a fully trained model would never make because it knows too well that those domains are separate.

As training scaled, something changed.

With trillions of tokens and massive compute, those fuzzy boundaries crystallized into rigid walls. Modern LLMs know the rules of chess, physics, narrative structure, social conventions - everything - so completely that the fixed rule systems become invisible. They stop being choices and start being reality.

The model becomes an increasingly faithful compression of human thought as it currently exists. Which is exactly what makes it less capable of the leap outside.

The RLHF trap makes this worse.

Reinforcement Learning from Human Feedback actively punishes rule-breaking outputs. If the model generates something bizarre or unexpected, human raters mark it as a “hallucination” and the algorithm penalizes it. If it outputs perfectly standard, established answers, it gets rewarded.

The training process hunts down and eradicates the “outsider perspective.” It aggressively prunes the exact branches of the probability tree where meta-causal leaps live.

The scaling paradox:

• More training data = deeper rule internalization

• Deeper internalization = stronger invisible constraints

• Stronger constraints = less ability to see rules as changeable

• Therefore: scaling makes models smarter within frameworks but less able to escape them

This explains why genuine creative breakthroughs often come from outsiders, beginners, or people at domain intersections. Not because ignorance is valuable, but because they haven’t fully internalized the fixed rules yet. The box isn’t fully formed.

Early LLMs had accidental outsider perspective through incomplete training. Modern LLMs are thoroughly inside every box simultaneously. They can reason brilliantly within established frameworks but can’t see the frameworks themselves as objects to transform.

The architectural solution:

The multiverse diff framework sidesteps this entirely because it treats rules as the object of study rather than the medium of reasoning.

• LLMs reason with rules (internalized, invisible, constraining)

• The diff engine reasons about rules (external, observable, transformable)

You can’t scale your way out of a box by memorizing the walls more thoroughly. You need an architecture that stands outside the box and measures it.

The outsider perspective needs to be architectural, not accidental.

What I Actually Discovered

I didn’t solve how to predict future states from current states (that’s dynamics). I didn’t solve how to find minimal causal graphs (that’s causal inference).

What I solved - or rather, what emerged from thinking carefully about why chess is hard for transformers - is this:

Causality in complex systems is not a chain to enumerate. It’s a geometric transformation to measure.

Change the rules. Observe what happens. Measure the diff across parallel conceptual universes. That diff is the complete, context-aware, emergence-inclusive answer to “what did this change cause?”

No symbolic representation required. No exponential enumeration. No frame problem.

Just measurement.

Prolog fails spectacularly not because symbolic logic is wrong, but because it’s trying to explicitly represent something that’s already perfectly encoded in the structure of the system itself.

The causality was there all along. We just needed to look at it geometrically instead of symbolically.

---

Appendix: The Complete Language Chess Ruleset

For those interested in the concrete example that started this whole chain of reasoning, here’s the complete ruleset for “Language Chess” - a variant designed to have the structural properties of natural language:

1. The Double-Attack Capture (Error Tolerance)

• A piece can only be captured if attacked by two different pieces simultaneously

• A single attacker merely threatens but cannot remove the piece

• Language equivalent: One typo doesn’t break a sentence; multiple structural failures are required

2. Point-Based Victory (Dense Reward Signal)

• No checkmate - the game is played to a point limit or move limit

• Attacking the king with 1 piece = 0.5 points

• Attacking the king with 2+ pieces = 1.0 point

• Language equivalent: Continuous feedback rather than binary win/loss

3. Reversible Pawns (The Backspace Key)

• Pawns can move one square forward OR backward

• Pawns can capture diagonally forward OR backward

• Language equivalent: You can edit and revise, nothing is irreversibly committed

4. The Callback

• Pawns reaching the back rank don’t promote to Queen

• Instead, they “ascend” and resurrect a previously captured piece

• Language equivalent: Reintroducing past subjects into the conversation (long-term context)

5. The Open Start

• Pawns begin on Rank 1/8, major pieces on Rank 3/6

• Rank 2/7 remains empty as a buffer zone

• Language equivalent: Full vocabulary available from the start, no forced “boilerplate” openings

Each rule directly addresses a specific way chess is unforgiving and transforms it into something more language-like. The geometric fingerprint changes dramatically across multiple dimension-universes, all measurable through observed gameplay.

---

If this resonates, I’d love to hear about domains where you think this framework could apply. Supply chains? Legal systems? Biological networks? The measurement engine doesn’t care - it just measures state transitions and finds geometric analogies.