The Universe Is a ComputerEpisode 2 / How to Compute
Counting the universe as a "computational process," without going through physics
How to Compute the Universe
The question splits into three layers — resources (how many bits, how many operations) / architecture (what kind of computer) / program (the update rule). Layer 1 is essentially settled. Layer 2 has strong candidates. Layer 3 is the gap.
Premise: universe = a computational process on finite resources (stated explicitly as a hypothesis)Hook: \(10^{90}\) bits, \(10^{120}\) operations
Once you see "the universe is a computer," the next question is then how does it compute? This splits into three independent questions — how many resources does it use, what kind of computer is it, and by what update rule (program) does it run? Taking them in order, the layer where the answer is known and the layer nobody has separate cleanly.
01Three layers — resources, architecture, program
1. Resources: memory (number of bits) and total operation count. → essentially answered
3. Program: the update rule that advances the state by one step. → the gap. Nobody has it
02Resources — here "computational complexity" gives the answer
You don't have to love physics; you can count purely (Seth Lloyd). The spec sheet for the computer called the universe:
The universe's resource spec
Memory: horizon area ÷ 4 (bits). The holographic bound gives \(\approx10^{122}\) bits; matter alone gives \(\approx10^{90}\) bits.
Total operations: energy × time ÷ \(\hbar\) (the Margolus–Levitin limit). Since the Big Bang, \(\approx10^{120}\) operations.
Clock: elapsed time.
And the key is how it grows. The horizon expands as \(\sim(ct)^2\), so both memory and operation count grow as the square of time:
How the RAM grows — this is what \(c\cdot t\) really is
$$N_{\text{bit}}(t)\;\sim\;\frac{(ct)^2}{\ell_P^2}\;=\;\left(\frac{t}{t_P}\right)^{2},\qquad \text{operations}\;\sim\;\left(\frac{t}{t_P}\right)^{2}$$
The universe = "a computer whose RAM grows as time squared." Last episode's watchword, \(c\cdot t\), was really the speed at which memory capacity grows. In terms of last time's growth order \(D=-d\ln F/d\ln n\), the growth order of resources with respect to time is 2.
Figure: how the RAM (number of bits) of the computer called the universe grows. Drag the slider through cosmic time (Planck time → now), and the memory \(N=(t/t_P)^2\) grows as a straight line of slope 2 on log–log axes. From 1 bit (Planck time) to \(10^{122}\) bits (now)
Drag the slider through cosmic time and the memory and operation count change.
Memory N = (t/t_P)² (slope 2)Present-day marker
This layer 1 is bookkeeping of computational complexity more than physics. Without adding a single hypothesis, you can flatly say "the universe = a computational process that has run \(10^{120}\) operations on \(10^{90}\) bits." This is solid ground.
◇ ◇ ◇
03Architecture — three candidates, with a clear ranking
So what is this computer made of? There are three serious candidates. And two observational facts (quantum correlations = Bell, no preferred frame = Lorentz invariance) sort them mercilessly:
The most "computer-like." A lattice of simple local rules.
Bell's inequality (quantum correlations) rules out classical local rules. A lattice has a preferred frame and breaks Lorentz invariance. It fights both major facts.
Quantum circuit (Lloyd, Deutsch)
Quantum is native. Unitary = reversible computation. Consistent with \(10^{120}\) operations.
Still assumes space and geometry as a given "array."
Tensor network (it from qubit)
Space and dimension are outputs (the wiring = geometry). Error-correcting codes protect locality.
The update rule is unknown. Rigorous results so far exist only inside the box (AdS).
The verdict of the sorting
A "literal lattice cellular automaton" is essentially dead (Bell + Lorentz). What survives is quantum computation, and if you want space itself to be an output, a tensor network. "Put the universe on a grid" is the very first idea to throw away.
04The program = the gap — and "run it," not "solve it"
What remains is the update rule. This is where computation theory speaks most sharply. And it's harsh:
Computational irreducibility (Wolfram): even with a simple rule, there may be no shortcut to the result — you can only actually run it one step at a time. If so, "computing the universe" is not about finding a clever closed formula, but rather it is impossible to predict any faster than real time.
A Kolmogorov-style lower bound: the shortest program that outputs the universe, \(K(\text{universe})\), cannot be made shorter than its information content. Compression has a floor (this is what last episode's "conservation of complexity" really was). "Make it simpler" hits this limit.
We know neither \(K\) nor the rule. All we know is the upper bound on resources (= the holographic memory floor).
05The checklist any valid update rule must pass
If you're going to write "the universe's program," it fails unless it passes all of these. These are the gates for being promoted to observation:
Pass conditions for the update rule
Reversible / unitary — it must not erase information (Landauer; no global bit erasure).
Local — bounded fan-in/out per step = a cap on information propagation = this is \(c\).
Lorentz-invariant — no preferred frame. = no grids allowed. This is where most candidates die.
Quantum — it must violate Bell's inequality. = naive classical local rules are out.
Geometry emerges — space = the adjacency structure of the state, not built in as an array.
06A minimal recipe you can run — one line at a time, in the native tongue
The most naive way to build something that passes the whole checklist above:
Hold the state as a graph / tensor network (not an array — for condition 3).
Update it with reversible local rewrites.
Impose a causal ordering (a partial order = causal set) on the rewrites (Lorentz can emerge from here).
Measure the emergent dimension with last episode's formula \(D=-d\ln F/d\ln n\) (= the growth order of reachable states), and check whether it flows toward \(D\to4\).
The realization — you land on the same blueprint as the physics you disliked
This recipe is really the Wolfram model / causal sets / CDT. Even if you enter from computation without going through physics, once you seriously work out "how to compute," you land in the same place as the blueprint physics reached by another route. Whether the entry is computation or physics, the frontier is one and the same.
The honest line
"The universe = computation" is a genuine and venerable lineage (Wheeler's it from bit, Zuse, Fredkin, Wolfram, 't Hooft's cellular-automaton interpretation, Lloyd). It's no crank idea. But "it is literally computation" is a hypothesis, not a theorem — getting both Lorentz invariance and quantum behavior (Bell correlations) out of classical computation is the unsolved hard part.
The resource estimates (\(10^{90}\) bits, \(10^{120}\) operations) are established complexity results. The sorting of architectures (a lattice CA struggling against Bell + Lorentz) is also an established argument. But layer 3, the update rule, is unknown — and if it's computationally irreducible, in principle there's no shortcut. Nothing in this document is "solved."
Practice problems (solvable from this one page)
Into which three layers does the question "compute the universe" split?
See the answer
1. Resources (how many bits, how many operations); 2. Architecture (what kind of computer); 3. Program (the update rule). Layer 1 is essentially answered (10⁹⁰ bits, 10¹²⁰ operations), layer 2 has strong candidates (quantum circuit ~ tensor network), and layer 3 is the gap.
Give two reasons "universe = classical cellular automaton" is essentially dead.
See the answer
(1) Bell's inequality — quantum correlations cannot be reproduced by classical local rules (local hidden variables). (2) Lorentz invariance — a fixed grid has a preferred frame and clashes with relativity. What survives is quantum computation, and to make space an output, a tensor network.
If the update rule is "computationally irreducible," what does "computing the universe" come to mean?
See the answer
Since there's no shortcut to the result, you cannot leap ahead with a clever closed formula; you can only actually run it one step at a time. = You cannot predict the universe's future any faster than real time. Not "solve" but "run."
Episode 2 summarySolid ground, strong candidates, one lone gap
"How to compute the universe" splits into three layers. 1. Resources is solid ground — \(10^{90}\) bits, \(10^{120}\) operations, RAM growing as time squared (= \(c\cdot t\)). 2. Architecture is already sorted — a lattice CA fails on Bell + Lorentz, the front-runner is the quantum circuit, and to make space an output, the tensor network. 3. The program alone is the gap, and if it's computationally irreducible, there's nothing to do but "run" it rather than "solve" it.
If you're going to write it, there are five gates — reversible, local, Lorentz-invariant, quantum, emergent geometry. The minimal build that passes them all is causal reversible graph rewriting, checked by whether last episode's \(D=-d\ln F/d\ln n\) flows to \(\to4\). Even entering from computation out of distaste for physics, you land on the same blueprint (Wolfram / causal sets / CDT).
This document is Episode 2 of "The Universe Is a Computer" series. The estimates of the universe's information content and operation count (Lloyd 2002: holographic bound \(\sim10^{122}\) bits, matter \(\sim10^{90}\) bits, \(\sim10^{120}\) operations, the Margolus–Levitin limit), the \(t^2\) growth of resources that accompanies horizon area \(\propto(ct)^2\), the exclusion of classical local hidden variables by quantum correlations (Bell's theorem), the tension between a fixed lattice and Lorentz invariance, reversible computation and Landauer's principle, computational irreducibility (Wolfram), the Kolmogorov-complexity lower bound, and the emergence of geometry via tensor networks / holographic codes, causal sets, CDT, and the Wolfram model are all established computation theory / physics, or active research programs. That "the universe is literally computation" is a hypothesis, and reconciling Lorentz invariance + quantum behavior from classical computation, as well as layer 3, the update rule, are current open problems. The numbers are order-of-magnitude, and the figure's \(N=(t/t_P)^2\) is a schematic of the holographic bound. — To print, use your browser's "Print" and "Save as PDF" (in the print version the slider and answers are static and hidden).
Print / PDF: Ctrl+P (⌘+P on Mac). On screen, the slider lets you watch the RAM grow as time squared against cosmic time. "See the answer" opens each solution.