The nature of the universe we find ourselves in is one of life’s great questions. Perhaps the largest hurdle in our attempt to understand the order of the universe is the fact that we must view everything from the inside. We cannot simply "step outside" to take a grand look at the universe from beyond its edges. Our perspective is necessarily entangled with the very system we seek to understand.

Like the prisoners in Plato's Allegory of a Cave who see only shadows cast on a wall, we too perceive only the patterns that unfold within the universe. The "light source" and the "outside" remain inaccessible- ever beyond the chains of our reality.

And yet, there is a curious way in which we can step "inward"— by creating small "universes" of our own.

Universes of Rules

Simple computational systems—cellular automata—take an initial state and update it according to a few deterministic rules. What makes them astonishing is that simple rules often generate complex behavior.

The most famous example is John Conway's Game of Life. With just four rules, phenomena such as oscillators, spaceships, and the iconic glider emerge.

There is an interesting asymmetry here: a Turing complete computer can encode itself, but it cannot be simulated by anything below Turing completeness. Thus, all parent systems of a sufficiently complex program must themselves be Turing complete. The Game of Life is itself Turing complete: given the right seed, it can compute anything that can be computed. It can even simulate itself.

Source: https://www.youtube.com/watch?v=xP5-iIeKXE8

But here we stumble upon a limitation: when Life simulates Life, the inner simulation runs vastly slower than the base universe, as the video shows. This raises a fundamental question: is it ever possible for a universe to simulate itself at the same speed—or even faster?

Reducibility and Irreducibility

This touches on the idea of reducibility. If a system is reducible, then its long-term behavior can be achieved by a simpler description or faster computation. For example, Rule 90 (an elementary cellular automaton referred to by its Wolfram code) generates the Sierpinski gasket. While the rule runs step by step, the pattern can also be generated directly using fractal geometry—a shortcut that bypasses simulating each cell.

But in irreducible systems, no such shortcut exists; to know the system's future state, you must compute each step. Life, in general, is thought to be computationally irreducible: you cannot know what a configuration will do without running it.

This makes self-simulation especially interesting. If the laws of a universe are irreducible, then a self-contained simulation must necessarily run slower than its parent. The only way around this is if the laws are partially reducible— if there are shortcuts.

For a tangible example, imagine a universe consisting of a single particle traveling at a fixed speed of 1 unit per update. We can "speed up" the simulation by a factor of k by moving the particle k units ahead of its current position in a single step; however, if the particle was unpredictable or governed by more complex laws, such a speedup in the same computational time would be challenging or impossible.

Minimal Requirements for Self-Simulation

Clearly, trivial systems (like a universe that just loops between two states) lack the complexity to simulate themselves. On the other hand, any system that is at least Turing complete can simulate itself. The natural question is: how simple can such a self-simulatable system be?

• Among the elementary cellular automata (systems with two possible states and nearest-neighbor rules), most produce simple or chaotic behavior. But Rule 110 is exceptional: it has been proven to be Turing complete. With minimal ingredients, it is capable of universal computation.
• Others, like Rule 54, are suspected of universality, though not fully proven.
• Meanwhile, rules like 60 or 90 produce fractal structures like the Sierpinski triangle— examples of self-similarity, but not self-simulatability.

This suggests an analogy:

• Fractals demonstrate self-similarity across scale (similarity of itself in itself).
• Universal computation demonstrates self-simulatability (computability of itself in itself).

Both reveal how simple rules can catalyze extraordinary complexity and seem to be connected in some unclear way. Perhaps the real "magic" is the recursive process itself.

Philosophical Consequences

If our universe is computationally universal, then in principle it could simulate itself. But if it is also irreducible, then any such simulation would necessarily lag behind the "parent universe." A child universe cannot outpace its parent unless there exist hidden shortcuts—reducible structures—built into the laws of nature.

This has two immediate implications:

1. If we ever succeed in simulating the universe as richly as it exists, it will almost certainly be slower.
2. Conversely, if we ever discover ways to run a faithful universe simulation faster than reality, this would imply that our universe itself is reducible— there would have to be shortcuts in its laws that allow acceleration. Reducibility would require fundamental insight into the structure of reality.

Of course, if our universe is truly non-deterministic, then even if it were found to be reducible, we would not be able to see ourselves through simulation. In the words of Werner Heisenberg,

"One could be tempted to conclude that behind the observed, statistical world a 'real' world is hidden... we believe such speculations... fruitless." (Physics and Philosophy: The Revolution in Modern Science)

Thoughts

By studying these toy universes—Life, Rule 110, and others—we touch on something beyond far beyond Mathematics and Computer Science textbooks. We are probing the boundary between simplicity and complexity, between structure and chaos, between rules and reality. And in doing so, we might learn something about the cave we inhabit, and about the very idea of stepping outside it.