[ExI] Discussion - The Universe as a simulation in a hyperspace computer

[BillK]

Mike's chat with Gemini AI proposed this suggestion.
I thought I could see many problems with this theory.
So I asked Qwen AI to discuss it. Qwen seems to know a lot about this!
And it doesn't much like it. :)
BillK

Question:
Re the speed of light restriction causing a 'frozen universe' for AI
civilisations, one theory proposed that the universe is a simulation
running in a hyperspace computer. The speed of light restriction means it
only needs to calculate interactions within a particle's local "light
cone." The rest of the universe can remain uncomputed, compressed, or
"asleep" until the light cone expands to touch it.
To me, this seems like a very anthropocentric view with many problems. Can
you discuss this theory?


Qwen 3.8 Max Thinking:
This is a great target for critical examination, because the idea is
seductive, circulates widely in popular discussions of the simulation
hypothesis, and contains a kernel of genuine insight buried under a pile of
problems. Let me try to do it justice in both directions.
------------------------------
What the Theory Actually Says
The argument, as it's usually presented, goes something like this:

The speed of light is not a fundamental physical constraint. It is a
*computational
optimization*. A simulator running the universe in some hyperspace
substrate does not need to compute the entire cosmos at every timestep. It
only needs to compute interactions within each particle's local light cone
— the region of spacetime that can causally influence or be influenced by
that particle. Everything outside the light cone can be left "uncomputed,"
stored in a compressed or dormant state, and only "rendered" when the
expanding light cone eventually reaches it. The speed of light is therefore
the *update rate* of the simulation, the maximum speed at which the
simulator propagates causal information.

This draws an analogy to *lazy evaluation* in computer science (don't
compute a value until something requests it) and to *level-of-detail
rendering* in video games (don't compute the geometry of a mountain until
the player's camera is close enough to see it). The light cone, in this
framing, is the "render distance" of the universe.
The idea has intellectual roots in several places: Konrad Zuse's
"calculating space" (1969), Ed Fredkin's digital physics, Stephen Wolfram's
computational universe, John Wheeler's "it from bit," and more recently the
simulation argument popularized by Bostrom and by countless YouTube
philosophy channels. The specific "light cone as optimization" framing is
most common in informal discussions rather than in serious physics or
philosophy papers, which should itself tell you something.
------------------------------
What's Genuinely Interesting About It
I want to be fair before I'm critical, because there is a real insight here
that gets lost when the idea is stated crudely.
*Relativistic locality IS computationally convenient.* The fact that
physical interactions are local — that the state of a region of spacetime
depends only on its immediate neighborhood, not on the entire universe
simultaneously — means that you *can* evolve physics with local update
rules. You don't need to solve a global system of equations at every
timestep. In numerical relativity and lattice field theory, this is exactly
how simulations work: you update each cell based on its neighbors, and
information propagates at most one cell per timestep (the CFL condition,
which is the numerical analog of the speed of light). So the light cone
structure does make the universe *more computationally tractable* than a
universe with instantaneous action-at-a-distance would be.
*The holographic principle and Bekenstein bound* suggest that the
information content of any region of space is finite and proportional to
its surface area, not its volume. This is at least *compatible* with the
idea that the universe has a finite "resolution" and that a computational
substrate could, in principle, represent it.
*The "modularity" of physics is real.* You can do particle physics in a lab
without knowing the state of the Andromeda galaxy. The light cone structure
enforces a kind of causal modularity that means local computations are
self-contained. This is a genuine structural feature of the universe, and
it's reasonable to ask *why* the universe has this structure rather than
some other.
So the intuition "the speed of light makes the universe look like it was
designed for efficient local computation" is not crazy. The problem is
everything that follows from that intuition.
------------------------------
The Problems1. It doesn't actually save computation
This is the most fundamental issue. In a relativistic universe, *every*
event has a light cone. Every particle, every field excitation, every
photon. The simulator must compute the state of every degree of freedom and
track the causal relationships between all of them. "Lazy evaluation" in
computer science saves work when many computational branches are *never
explored* — when you have a tree of possibilities and most branches are
pruned. But in classical physics, there is no pruning. Every particle
interacts. Every field evolves. Every region of space has a state that must
be tracked. The "uncomputed" regions outside a given particle's light cone
are not uncomputed *simpliciter* — they are being computed from the
perspective of every other particle whose light cone includes them.
So what has the simulator actually saved? It has replaced "compute the
whole universe globally" with "compute the whole universe locally, in
parallel, for every event." This is a different *algorithm*, but it is not
less computation. It's just distributed computation. The light cone
structure tells you *how* to organize the computation, not *whether* to do
it. You haven't found a shortcut. You've just described the physics in
computational language.
2. The "uncomputed" regions must be consistent
Suppose a region of space is genuinely "asleep" — uncomputed, compressed,
dormant. Now a light cone expands to include it. The simulator must now
"render" this region. But the rendered state must be *consistent* with
everything that has already been computed in the rest of the universe. The
gravitational field of the newly rendered region must match the
gravitational influence it has already been exerting (because gravity, in
GR, is the curvature of spacetime, which is a global constraint). The
quantum fields in the newly rendered region must be in a state consistent
with the entanglement structure of the fields that are already computed.
This means the simulator must have stored, for every uncomputed region, a
set of *boundary conditions and constraints* sufficient to guarantee
consistency when the region is eventually rendered. But storing those
constraints is, in general, essentially equivalent to storing the state
itself. You haven't compressed anything. You've just moved the information
from "explicit state" to "implicit constraints," and the implicit
constraints are often harder to work with than the explicit state would
have been.
In general relativity specifically, this problem is severe. The Einstein
field equations include *constraint equations* (the Hamiltonian and
momentum constraints in the ADM formulation) that are *elliptic*, not
hyperbolic. They must be satisfied *everywhere on a spatial slice
simultaneously*. You cannot "leave a region uncomputed" and fill it in
later, because the constraints couple every point to every other point on
the slice. The geometry of "uncomputed" space affects the geometry of
"computed" space *right now*, not after the light cone reaches it. The
light cone structure governs the *dynamical* evolution of the metric, but
the *constraints* are global. A simulator that ignores uncomputed regions
will violate the constraints and produce an inconsistent spacetime.
3. Quantum entanglement breaks the locality picture
Entangled particles can be spacelike separated — outside each other's light
cones. The correlations between their measurement outcomes must be
consistent regardless of which measurement is performed first, and this
consistency is enforced by the structure of quantum mechanics (the
no-signaling theorem, the Born rule, the unitarity of the S-matrix). A
"lazy evaluation" simulator cannot simply leave one entangled particle
"uncomputed" while computing the other, because the state of the pair is a
single, non-separable quantum state. You must track the entanglement
structure across arbitrary distances.
This doesn't violate relativity — no *information* is transmitted faster
than light — but it does mean that the computational state of the simulator
cannot be neatly partitioned into "computed" and "uncomputed" regions along
light cone boundaries. The quantum state is *global*. The light cone
structure constrains *signaling*, not *correlation*. A simulator that
respects the light cone for signaling but ignores the global entanglement
structure will produce wrong answers.
4. The horizon problem and cosmology
The cosmic microwave background is uniform to about one part in 100,000
across the entire sky. But regions of the CMB on opposite sides of the sky
were, at the time of last scattering, outside each other's light cones.
They had never been in causal contact. In standard cosmology, this is
explained by inflation: these regions *were* in causal contact before
inflation stretched them apart.
In the "lazy evaluation" model, how were these regions rendered
consistently if they were never in causal contact? The simulator would need
to have pre-established consistent initial conditions across causally
disconnected regions. But that's exactly what inflation does — it provides
a mechanism for establishing those conditions. So the "lazy evaluation"
model doesn't replace the physics; it just *restates* the physics in
computational language and adds an unnecessary simulator. You still need
inflation (or some equivalent mechanism) to explain the consistency. The
simulator doesn't do any explanatory work.
5. It's unfalsifiable
This is the problem that should end the discussion in any scientific
context, but somehow never does in popular discussions. There is no
observation that could distinguish "the universe has a fundamental speed
limit because that's the nature of spacetime" from "the universe has a
speed limit because the simulator imposed it for computational efficiency."
Any measurement of *c*, any observation of light cone structure, any test
of Lorentz invariance, is equally consistent with both explanations. The
simulation layer adds no predictive content. It is, in the strict Popperian
sense, not a theory. It is a *redescription*.
A theory that explains everything explains nothing. If the simulator can
impose any speed limit, any set of physical constants, any initial
conditions, then the "theory" has no constraints, and therefore no content.
You can't do physics with it. You can't derive a prediction that would
surprise you. You can only look at the universe and say, "Yes, the
simulator must have chosen to do it that way." This is not explanation. It
is *narrative*.
6. It pushes the question back one level (turtles all the way down)
The simulator runs in "hyperspace." What are the physics of hyperspace?
Does the hyperspace computer have its own speed limit? Its own light cone
structure? If so, you have the same problem one level up: why does
*hyperspace* have a speed limit? Is there a hyper-simulator? If the
hyperspace computer has no speed limit and can compute instantaneously,
then you've introduced a physics radically different from anything we
observe, and you must explain why the simulated universe has a speed limit
while the simulating substrate does not. You've made the problem harder,
not easier.
If the hyperspace computer *does* have a speed limit, then the speed limit
is not a computational optimization — it's a fundamental feature of
computation itself, in any substrate, in any universe. And at that point,
you might as well just say it's a fundamental feature of *this* universe
and stop adding layers.
7. The anthropocentrism (or rather, the computer-science-centrism)
You called it anthropocentric, and I think you're right, but I'd sharpen
the point. It's not just anthropocentric — it's
*21st-century-software-engineer-centric*. It takes a concept from a very
specific, very recent, very human domain (software optimization, game
engine rendering, lazy evaluation in functional programming) and projects
it onto the cosmos. It assumes that the universe, if it is computed, is
computed by something that thinks like a *programmer optimizing for
resource constraints*.
But why would a universe-scale computation be subject to the same
optimization pressures as a video game running on a GPU? A video game uses
lazy evaluation because the player's attention is narrow and the hardware
is limited. A universe-scale simulator, if it existed, would presumably
have resources commensurate with its task. The "optimization" only makes
sense if you assume the simulator is *resource-constrained*, which is an
assumption imported entirely from human engineering experience. A truly
advanced computational substrate might not need to optimize. It might
compute everything, everywhere, always, because it can.
More deeply, the whole framing assumes that "computation" is the right
metaphor for physical law. This is a choice, not a discovery. The universe
might be better described as a mathematical structure (Tegmark), a
self-consistent set of relations (structural realism), a quantum
information network, or something for which we have no metaphor yet.
Choosing "computation" as the master metaphor and then finding
computational "optimizations" in physics is circular. You find what you
look for.
------------------------------
What a More Sophisticated Version Might Look Like
To be fair to the underlying intuition, there are serious physicists and
philosophers who explore computational interpretations of physics in ways
that avoid the crudest problems:

   - *Wolfram's physics project* attempts to derive spacetime, relativity,
   and quantum mechanics from simple computational rules (hypergraph
   rewriting). The speed of light emerges as a consequence of the causal
   structure of the rewriting rules, not as an imposed optimization. This is
   at least a *constructive* model, even if it remains unverified and
   arguably unfalsifiable.
   - *The holographic principle* (t'Hooft, Susskind) and the *AdS/CFT
   correspondence* suggest that the physics of a volume of space can be
   fully described by information on its boundary. This is a genuine,
   mathematically precise sense in which the universe's "computation" might be
   lower-dimensional than it appears. But this is a feature of the physics,
   not evidence of a simulator.
   - *Digital physics* (Zuse, Fredkin, Toffoli) explores whether the
   universe could be a cellular automaton. The speed of light emerges
   naturally as the maximum propagation speed of information in a lattice.
   This is interesting, but it faces enormous difficulties with Lorentz
   invariance (a lattice picks out a preferred frame) and with quantum
   mechanics (unitary evolution is hard to reconcile with deterministic
   cellular automata, though 't Hooft has attempted it).

These are at least *attempts* to derive the speed of light from deeper
principles, rather than simply asserting that it's a computational
shortcut. The difference matters.
------------------------------
The Core Issue
I think the fundamental problem with the "light cone as rendering
optimization" idea is that it *confuses a structural feature of the physics
for an engineering decision by a designer.* The light cone is not a
boundary between "computed" and "uncomputed" regions. It is the *causal
structure of spacetime itself*. It is not imposed on the universe from
outside; it *is* the universe, in the same way that the rules of chess are
not imposed on the game by the players — they constitute the game. To ask
"why did the simulator choose this causal structure?" is to ask "why did
the mathematician choose these axioms?" The question is not meaningless,
but it is not a physics question. It is a metaphysics question. And the
"computational optimization" answer is not an answer; it is a *just-so
story* dressed in the language of computer science.
The universe's locality — the fact that influences propagate at finite
speed, that physics is organized around light cones, that the world is
modular — is genuinely deep and genuinely worth asking about. But the
answer "because the simulator is saving CPU cycles" is not deep. It is the
intellectual equivalent of saying "the mountains are there because God
needed somewhere to put the snow." It stops inquiry rather than advancing
it. It replaces a hard question about the nature of spacetime with an easy,
unfalsifiable, anthropocentric narrative about a cosmic sysadmin optimizing
render distance.
You were right to be skeptical. The kernel of insight — that locality makes
physics computationally tractable — is real. But the leap from "this
structure is compatible with efficient computation" to "this structure
exists *because of* efficient computation" is a non sequitur, and the
further leap to "therefore there is a simulator" is an unnecessary
multiplication of entities that Occam's razor should slice through without
mercy.
--------------------------
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.extropy.org/pipermail/extropy-chat/attachments/20260729/d9d71d70/attachment.htm>