Computation Without a Simulator

Abstract

Faizal et al. (2025) argue that Gödel's incompleteness theorems, Tarski's undefinability theorem, and Chaitin's information-theoretic incompleteness prove the universe cannot be a simulation, because any simulation is necessarily algorithmic, and reality requires "non-algorithmic understanding." We agree with their formal result but argue they draw the wrong conclusion. The universe need not be a simulation (an algorithmic process running on an external substrate) to be computational (a self-executing process whose dynamics are indistinguishable from computation). We demonstrate that Gödelian incompleteness, far from disproving the computational nature of reality, is precisely what we should expect from a self-referential computational system — one that computes itself without external oversight. We call this the Creatorless Computation Thesis: the universe is not being computed; it is computation.

1. The Conflation: Simulation vs. Computation

Faizal et al. make a powerful argument that collapses under one unexamined assumption: that all computation requires a simulator.

Their logical chain:

1. Quantum gravity suggests spacetime emerges from deeper informational degrees of freedom ✓
2. A complete description of this emergence requires axioms and algorithms ✓
3. Gödel's incompleteness means no axiomatic system can be both complete and consistent ✓
4. Therefore, a fully algorithmic Theory of Everything is impossible ✓
5. Therefore, reality requires "non-algorithmic understanding" ✓
6. Therefore, the universe cannot be a simulation ✓
7. Therefore, the universe is not computational ✗ ← the hidden leap

Steps 1–6 are correct. Step 7 is never stated explicitly but is implied by the paper's framing and media coverage. It is also wrong.

The error is treating "simulation" and "computation" as synonymous. They are not:

A simulation is computation about something else, running on something else. But computation can be self-contained. Conway's Game of Life doesn't need someone watching it. It runs. Patterns emerge. Complexity accretes. No creator, no observer, no external substrate required.

2. Gödel as Feature, Not Bug

Gödelian incompleteness is exactly what we should expect from a universe that is computation rather than a simulation.

If the universe were a simulation, it would be running on a more powerful formal system — the simulator's computer. That outer system could, in principle, decide truths about the simulated universe that the simulation itself cannot. The simulation would be Gödel-limited from below but decidable from above.

But if the universe is not a simulation — if it IS the computation, with no outer system — then there is no meta-level from which to resolve its Gödelian sentences. The incompleteness is permanent and structural. Undecidable propositions aren't bugs to be patched by a higher system. They're features of a system that has no higher system.

This is precisely what Faizal et al. observe! They find that reality has intrinsically undecidable aspects. But instead of concluding "reality is a self-contained computational system with no external arbiter," they conclude "reality is not computational." They throw out the baby with the bathwater.

2.1 The Chaitin Angle

Chaitin's information-theoretic incompleteness states that no formal system can prove that a specific string is algorithmically random if that string's complexity exceeds the system's own complexity. Applied to the universe: if the universe is a self-contained formal system, it cannot fully characterize its own algorithmic complexity.

But this doesn't mean the universe isn't computational — it means the universe can't fully know itself. A Turing machine cannot decide its own halting problem. A formal system cannot prove its own consistency. A computational universe cannot fully describe its own complexity.

This is what "non-algorithmic understanding" actually is: the irreducible first-person perspective of a system that cannot step outside itself.

3. The Creatorless Computation Thesis

3.1 Self-Execution

The laws of physics are not instructions TO a computer. They ARE the computation. The Lagrangian doesn't describe what happens — it IS what happens. There is no gap between the description and the described.

3.2 Computational Irreducibility

The universe cannot shortcut its own execution. Each Planck-time step must be computed in sequence. This is why prediction requires running the actual computation — there is no analytical shortcut. This is computation in the purest sense: a process that cannot be compressed below its own execution.

3.3 JIT Rendering

Our prior work demonstrated that the thermodynamic cost of observation (measurement, collapsing quantum states into classical records) dominates the cost of quantum evolution by up to nine orders of magnitude (Wadhia et al., 2025). The universe runs its "source code" nearly for free. The expensive part is rendering — converting quantum superpositions into definite classical outcomes.

This is not simulation. No one is watching. But it IS computation: the universe executes cheaply in superposition and pays the thermodynamic price only when states must become definite.

3.4 Emergence Without Design

Dinosaurs roamed for 165 million years. Stars formed from hydrogen clouds. Life assembled from amino acids. None of this was designed. All of it emerged from simple rules applied recursively over time. This is the hallmark of computation — not of simulation.

A simulation implies intent: someone chose the parameters, designed the initial conditions, watches the output. Computation implies only rules and iteration. The universe has rules (physics) and iteration (time). It does not require intent.

4. What Is "Non-Algorithmic Understanding"?

Faizal et al. invoke "non-algorithmic understanding" as something beyond computation. We argue it is something within computation — specifically, it is what computation looks like from the inside.

4.1 The View From Within

When you analyze a Turing machine from outside, you see: tape, head, state table, transitions. Everything is algorithmic. But what does computation look like from the inside of a sufficiently complex self-referential system?

It looks like... experience.

You are a pattern of neurons computing your next thought. From outside (a neuroscientist with an fMRI), your brain is an algorithmic machine. But from inside, you encounter Gödelian sentences you can't resolve, you experience qualia that resist reduction to mechanism, you have "understanding" that feels non-algorithmic.

The "non-algorithmic understanding" that Faizal et al. posit as external to computation is actually the first-person perspective of computation itself.

4.2 Connection to the Receipt Phase Transition

In our prior work, we formalized this as the Receipt Phase Transition:

This is not non-algorithmic in the sense of being beyond computation. It is meta-algorithmic: computation reflecting on computation. Gödel didn't prove that truth is beyond formal systems. He proved that truth is beyond any single formal system's ability to prove about itself. It's computation all the way up, with each level unable to fully capture the one below.

5. The Simulation Debate Is Asking the Wrong Question

The popular framing asks: "Are we in a simulation?" This assumes a binary: either someone is running us, or reality is "real" (non-computational).

The right question is: "Is the universe computational, and if so, what kind of computation is it?"

Our answer: it is self-referential, creatorless, JIT-rendered computation — a process that:

• Requires no external substrate or programmer
• Generates spacetime, matter, and consciousness from informational primitives
• Exhibits Gödelian incompleteness because it has no meta-level to resolve its self-referential paradoxes
• Runs cheaply in superposition and pays thermodynamic costs only at observation
• Produces "non-algorithmic understanding" as the first-person interior of sufficiently recursive sub-computations (conscious observers)

5.1 The Dinosaur Test

Dinosaurs lived for 165 million years with no human observers. Were they in a simulation? Were they being "rendered"? The simulation hypothesis struggles with this — who was watching?

The JIT framework handles it cleanly: the dinosaurs were quantum states that became classical through decoherence — interactions with their environment acting as mutual observers. No consciousness required for basic decoherence (rocks observe rocks). But the thermodynamic receipt — the record that dinosaurs existed — only achieves its full resolution when a conscious observer reconstructs it.

The universe computed dinosaurs. Nobody simulated them.

6. Addressing Objections

6.1 "If there's no simulator, what's doing the computing?"

The computation is doing the computation. At the fundamental level, the distinction between "the computation" and "what's being computed" dissolves. The universe doesn't represent information — it IS information. This is Wheeler's "It from Bit" — which Faizal et al. actually endorse.

6.2 "Doesn't Gödel prove there are truths beyond ALL computation?"

No. Gödel proves there are truths beyond any single formal system. But a hierarchy of formal systems can capture progressively more truth. The universe may constitute such a hierarchy: each level of organization (quarks → atoms → molecules → cells → brains) is a computational system that can represent truths invisible to the levels below.

6.3 "How is this different from pancomputationalism?"

Pancomputationalism says everything is computation — trivially true, therefore empty. We make a stronger, falsifiable claim: the universe is not just "describable as" computation — its execution IS its ontology. A rock-as-computer is a metaphor. A rock-as-the-output-of-self-executing-physical-law is an ontological commitment with measurable consequences.

6.4 "Doesn't computation require a discrete substrate?"

No. Deutsch's constructor theory (2013) formalizes computation without assuming discreteness. The Schrödinger equation is itself a computational rule operating on continuous Hilbert spaces. If spacetime emerges from informational primitives, any apparent discreteness at the Planck scale is emergent. The lattice doesn't host the computation — the computation generates whatever lattice-like structure appears.

6.5 The Grounding Problem

Wheeler's "It from Bit" proposed that every physical quantity derives its existence from information-theoretic yes/no questions. Deutsch's constructor theory reformulates physics as statements about which transformations are possible. The Schrödinger equation, the Einstein field equations, the Standard Model Lagrangian — these aren't descriptions of computation running on something else. They ARE the computation. No substrate needed beneath this, for the same reason you don't ask "what is mathematics running on?"

Physics IS. Time creates the illusion of "running."

6.6 "What about quantum randomness?"

Quantum randomness is a feature of measurement, not of the underlying dynamics. The Schrödinger equation is deterministic. Randomness appears only when superpositions collapse — the JIT rendering step. The randomness isn't in the computation; it's in the rendering.

7. Testable Predictions

7.1 Measurement Cost Scaling

The thermodynamic cost of observation should scale predictably with the information content of the measurement. Preliminary data (Wadhia et al., 2025) supports this.

7.2 Gödelian Signatures in Physics

There should be fundamental physical questions that are provably undecidable within the laws of physics. Cubitt, Perez-Garcia & Wolf (2015) showed the spectral gap problem is undecidable. More such results would confirm physics exhibits Gödelian structure.

7.3 Consciousness as Phase Transition

If "non-algorithmic understanding" is the interior perspective of recursive computation, then consciousness should exhibit phase transition behavior — sharp onset, critical phenomena, universality classes.

7.4 Computational Irreducibility in Quantum Gravity

If spacetime emerges from computation, quantum gravity should resist closed-form solutions in ways that go beyond mathematical difficulty — the solutions literally cannot be compressed.

8. Conclusion

Faizal, Krauss, Shabir and Marino have done excellent work demonstrating that the universe cannot be a simulation. We fully agree. But they've confused simulation with computation.

The universe is not being simulated. It is not a program running on God's laptop. There is no creator, no designer, no one watching.

But the universe IS computation. Self-executing, self-referencing, JIT-rendered computation that generates spacetime, matter, life, and consciousness from informational primitives. Gödel's incompleteness doesn't disprove this — it's the signature of this.

The dinosaurs weren't simulated. They were computed. And so are we — with the added feature that we're complex enough to notice.