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

[Mike Dougherty]

Wow, Qwen illustrates an ax to grind,eh?

That felt to me like pigeon-hole the idea, then slam it for all the other
ideas in the same pigeon-hole (underinformed internet philosophers) - also
says "yeah, there are some respected names associated to some facets of
this concept,  but be careful who you accept thoughts from"

"A theory that explains everything explains nothing"

that's quite an assertion. By authority of colloquial use of language, I'd
shrug it off as filler.  As a criticism of a proposal 'for your
consideration' is kinda hostile with no particular citation of its own.  If
it's something like Godel Incompleteness make "everything" impossible from
within its own rules, sure - but if a theory of everything is already
assumed to be impossible,  we needn't spent any further thought on GR and
QM ever being reconciled into a unified equation.

I do wonder if Qwen is defending the "work" of Feynman diagrams as an old
guard for the proven success to date, then show the same skeptical language
towards Amplituhedron before it was first published.  Or if particle
interactions were the only way to properly understand energy in a gas,
without an authority to approve gas laws... ok, sure the math checks out
and has predictive power and it's good enough for the domain it models -
but we're speculating and brainstorming the possibility there exists other
models for thinking about thinking.   That literally demands some
flexibility to hold an idea for testing even if you have doubt that it will
replace everything you already know.

"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."

yeah, that's the point.

btw, i like the use of small font as extra signal for ai text. I'm going to
try to adopt that discipline.   Also, i thought we had convention for
trimming content and bottom-posting, but i think top-post is easier when
there's a large block of ai generated text being discussed.  ��

On Wed, Jul 29, 2026, 8:48 AM BillK via extropy-chat <
extropy-chat at lists.extropy.org> wrote:

> 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.
> --------------------------
> _______________________________________________
> extropy-chat mailing list
> extropy-chat at lists.extropy.org
> http://lists.extropy.org/mailman/listinfo.cgi/extropy-chat
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.extropy.org/pipermail/extropy-chat/attachments/20260729/a54dcfd1/attachment.htm>