An Unsimulated Simulation

The Simulation Hypothesis

Bob is an alien in an alien universe with a googol times as many resources as the entire earth combined.Bob decides, as anyone would do in his situation, to simulate a universe.

1. Bob builds an enormous supercomputer
2. Bob writes a program that simulates a universe
3. Bob lets it run

Bob just so happened to pick some rules that cause an emergent universe to form, with a big bang, and galaxies and stars and planets. On one of those planets intelligent life evolves, a civilization develops, and an organism named Alice is born.

Alice, a conscious being like yourself, lives her life unaware that she resides within a simulated universe.

The simulation hypothesis can explain why our universe exists, but it moves the question to explaining why Bob’s universe exists. Many people can accept it as possible in theory.

Let's see where the assumption that it is possible can lead.

...

Alice's Computable Function

Does Bob need to be aware of Alice's existence in order for her to exist? In many simulation hypothesis scenarios, it is not required for the builder to be aware of life for it to "exist". It is hard to imagine Bob intricately watching every organism of the universe he created, even if he monitors a few. From Alice's perspective, she is unaware of Bob or the fact that she is in a simulation.

If Bob is not required to be made aware of Alice's existence, then clearly Alice does not exist as a representation within Bob's mind, and instead exists as some internal representation within Bob's computer, some binary information encoding the states of all the atoms that make up her mind.

This is perhaps not surprising, and is what many people think of when they think of the simulation hypothesis. However, since Bob need not be aware, there is no frame of reference for what satisfies an internal representation.

Why not? Can't we make restrictions on how Bob's computer stores this internal representation? Let's push it and see if we can draw a line somewhere.

Note that "Alice's universe" also includes its laws (the code that runs it), and that a "representation" contains the stored information along with whatever unpacks it.

1. A high precision encoding of Alice's universe
2. The same encoding, but every byte is inverted
3. The same encoding, but stored as a lossless compressed .zip file
4. Any arbitrary lossless compression algorithm

The next step would be a lossy compression algorithm that cannot perfectly recover Alice. Here though, we can draw a line; some of Alice is gone, and in the extreme case, all of her.

We started with the assumption that #1 can be Alice, so as long as the input combined with the decompressor can recreate Alice, we should accept it.

Let's assume Bob's program is a state machine, and that Alice sprang into existence at state . If Bob's program is deterministic, then state losslessly encodes state , since is perfectly recoverable from it by running one iteration of Bob's program, which functions as a decompressor. By extension of the same argument, this is also true for etc. all the way back to the initial state of Bob's simulation .

Therefore, Bob's computer had an internal representation of Alice as soon as Bob loaded the program into his computer's memory, albeit a compressed one.

Assuming Bob has infinite time on his hands, he could go further, and ditch his computer. Armed with no more than pen, paper, Alice's program, and a description of his computer, he could run Alice's simulation himself. Applying the same logic as previous, a representation of Alice exists as soon as Bob wrote down the program and the computer description on a piece of paper.

A program & a description of a computer to run it specifies a "computable function"; what Bob has just done is write down "Alice's computable function".

From all this, it appears reasonable to postulate the absurd statement that there is no meaningful difference from the perspective of Alice between Bob running Alice's computable function on his computer and Bob writing down Alice's computable function.

So we are reduced to:

Bob writes a program that simulates a universe

...

Bob's Universal Iterator

Does Bob even need to write down Alice's computable function though?

Suppose that Bob, instead of writing the program that simulated Alice's universe, wrote a program that enumerates and runs all possible programs he could’ve written.

Here's a Python program you can run today that will enumerate all possible brainfuck programs and run them for a googolplex steps each.

from itertools import count, product
GOOGOLPLEX = 10**(10**100) # Change this if you want to actually run it

def run(program):
 tape, head, pos, steps = {}, 0, 0, 0
 while pos < len(program) and steps < GOOGOLPLEX:
 op = program[pos]
 if op == '+': tape[head] = tape.get(head, 0) + 1
 elif op == '-': tape[head] = tape.get(head, 0) - 1
 elif op == '>': head += 1
 elif op == '<': head -= 1
 elif op == '[' and not tape.get(head, 0):
 depth = 1
 while depth:
 pos += 1
 if pos >= len(program): break
 if program[pos] == '[': depth += 1
 elif program[pos] == ']': depth -= 1
 elif op == ']' and tape.get(head, 0):
 depth = 1
 while depth:
 pos -= 1
 if pos < 0: break
 if program[pos] == ']': depth += 1
 elif program[pos] == '[': depth -= 1
 pos += 1; steps += 1

for length in count():
 for program in product('+-<>[]', repeat=length):
 run(''.join(program))

Since this program contains the program that simulated Alice, this program also simulates Alice. Therefore all of the previous reasoning applies, and from Alice's perspective this should be the same.

This idea of a Universal program that simulates universes was explored by Jürgen Schmidhuber whose "Great Programmer" ran this kind of program. We should note that while Alice exists encoded in this program, so do infinitely many other things, including different versions of her. This creates a problem of "finding Alice", which will be discussed more later.

This reduces us to:

Bob writes a program that runs all possible simulations

...

Alice in a Void

What is Bob actually doing at this point? He is only specifying a program that iterates over all programs. This seems like not that much work.

Following the trend of reductionism, ideally we eliminate Bob, such that Alice can exist independent of anything else, allowing her to exist in a void.

To do this requires a postulate perhaps best described as Platonism. This involves believing the rules of John Conway's Game of Life predate John Conway, and that the life of a glider on an infinite grid predates him as well; he just discovered it.

The same could be said for the original Alice's computable function as well. You can make this jump without the program-computing program; it just smooths things over a bit.

With this additional postulate, Bob did not invent but discovered this program-enumerating program as well; it always existed. Alice never needed Bob to exist. Alice never needed anything to exist.

...

Finding Alice

From all this, we would believe that every possible simulated universe "exists" within a void, requiring nothing. Taking the original assumption of the simulation hypothesis, such a universe could also contain something similar to yourself.

Right now, you, the reader, are experiencing what is known as an "observer-moment". That is, you have some perspective from which you experience something. We noted previously the problem of finding Alice within an infinite space. This then offers a way to solve that problem, as we know Alice experiences at least one observer moment.

We can then invoke the anthropic principle, claiming that because we are experiencing an "observer-moment", we are some entity such as Alice, allowing us to localize within the infinite. While we obviously don't recover exactly Alice, the hope is to recover something similar in order to explain our own existence.

Max Tegmark proposed the Mathematical Universe Hypothesis (later refined in part to the Computable Universe Hypothesis), which is essentially where we have arrived. It originally said that we should expect to be randomly drawn from a distribution of all observer-moments created from all possible mathematical constructs, weighted equally.

Unfortunately, there is a problem: weighting them equally isn't possible, because "equally" still needs to be measured relative to something; it's not possible to weight infinitely many things equally. We need a measure, or a way of deciding how to weight all possible constructs, in order to explain anything at all about the universe we find ourselves within. If we don't have this, we likely won't find Alice, and will instead find something completely random and chaotic that happens to experience an observer moment.

...

Measure

Jürgen Schmidhuber's great programmer's program-iterating program provides a natural measure, or ordering, over the set of all possible computable programs. However, this requires fixing a program-iterating program, and if you make the jump to Platonism, fixing one doesn't make much sense either.

Some measures can be more natural than others; one of these is known as the "Solomonoff" prior which involves weighting all possible inputs to a Universal Turing Machine (UTM) by 2^-L where L is their length in bits. This has some natural consequences like simple programs showing up much more often, which may explain why our universe has fairly simple rules. For weighting observers instead of universes, each observer can be given an "address" that specifies where in the program they appear; that address is also counted as part of the weighting. Taking this gives you what is known as UDASSA.

Another proposed one is the "Speed" prior, which comes from running a program named "FAST" that computes all possible programs, and says we should consider programs based on the proportion of time FAST spends computing them. This naturally favors simpler universes, with some tantalizingly testable predictions about our universe, for example we would expect seemingly random things such as beta decay to follow cheaply computable (and potentially reverse-engineerable) pseudorandom algorithms.

Note that in either case, the weighting isn't needed for Alice to exist; rather, it is needed to calibrate what kind of observer Alice should expect to be.

However, all of these measures require fixing some specific Universal Turing Machine. While all UTMs are computationally equivalent, how they weight their input strings is not. For example, the input "111111" to one UTM could mean the same as "11" to another. This means that to use (for example) the Solomonoff prior, some UTM implementation must be fixed. Similar to before, this is difficult to rationalize if the jump to Platonism was made.

Dominance

The problem of measure persists. The only way to get rid of the measure claim is to replace it with a "dominance" claim. Instead of saying "most mathematical structures create simple universes", this would entail conjecturing that "all mathematical structures that create complicated universes also create simple universes in a ratio heavily skewed towards simple ones". If this conjecture is true, a measure claim is not required, simple universes will always outnumber complicated universes no matter the measure.

There are some things that point towards this conjecture. Our universe seems to have around 17 quantum fields that interact with one another. An assumption thus far is that each program or structure simulates one universe; perhaps we are only a subset of a very large mathematical structure with trillions of fields.

The dominance conjecture gestures towards some falsifiable predictions:

1. Our physics is an emergent layer over a more complex low-level structure.
2. There may be significantly more fields that only occasionally interact with the "main" ones.

However, despite the best arguments, it will always be unreasonable to claim it true for all structures. "Almost all" does not suffice for a dominance claim, and it is the best we can do since there is the counterexample of a structure that only initializes a complex chaotic universe and does nothing else.

The "almost all" conjecture is still relieving in some part. Taking it to be true, if there is a "correct" measure for the platonic realm, as long as it does not go out of its way to count these rare exceptional structures significantly more, we are fine, and we should expect to reside in a simple universe.

With this problem partially addressed, we are free to invoke the anthropic principle and to imagine ourselves as an Alice in a void.

...

Prior Art

The ideas within this chain of reasoning are scarcely original, and have been much refined based on the following prior art:

Max Tegmark
MUH/CUH

Jürgen Schmidhuber
Great Programmer
Various Measures / Priors

Hal Finney / Wei Dai
UDASSA

Bruno Marchal
Universal Dovetailer, reached through duplication argument

...

Rabbit Holes

• Does this imply something special about a time axis, what about relativity?
  • Not necessarily, the simulation could build a structured 4D universe representation. As for relativity, I'm not sure what kind of simulation can work, but this is baked into the computability assumption and is also specific to the simulation hypothesis case regardless. The compression along time axis argument uses time as an example, generic compression of high dimensional structures applies the same way.
• Regarding the Simulation Argument
  • The argument that there are more "simulated" worlds than "real" worlds doesn't apply here now that all worlds are simulated and none are real. Some simulated worlds may simulate other worlds, so being in a simulated simulation is not ruled out.
• Consciousness/Observer-Moments
  • Starting with the initial "simulation hypothesis is possible" lets us deliberately avoid this question in favor of only explaining the tangible (I am an organism in a universe, why?). Alices are found by applying the anthropic principle to functional entities with similar localized information to that in my own brain, which is why Boltzmann brains are a hazard.
• Boltzmann Brains
  • Many universes could produce something similar to yourself, complete with all your memories, for a fleeting moment, only for it to rapidly decay. This is known as a Boltzmann brain and it is terrifying; we would like to avoid concluding that you likely are one.
  • A brief aside: Judging an argument by whether it leads to the conclusion that you are a Boltzmann brain feels weird, since the entire point of an actual Boltzmann brain is that you can't know that you aren't one. I often feel like the reasoning implicitly goes "This scenario would mean I likely am a Boltzmann brain, but I'm not, so therefore it's invalid". The "I'm not" is often subconscious. I notice this in myself of course, which possibly explains some of the reasoning here.
  • UDASSA addresses this problem by including the address of the observer in its weighting, meaning observer-moments in simple universes are cheap to specify while Boltzmann brains aren't. Conjecturing that "all Boltzmann brain programs also run simple-universe computation in a ratio that favors observer-moments produced by the simple universe computations" allows you to move away from a measure claim and towards a dominance one. This has the same "almost all" problem as before, meaning a claim on disallowed measures is required.
• Putnam's Rock / Searle's Wall / Chalmers Rebuttal
  • Putnam and Searle argued independently that if there's no absolute frame of reference for what implements a program, a rock or wall computes a program if the correct frame of reference is chosen. This is exactly what we abused to get from Bob running the program to Bob specifying the program, and then made the jump to Platonism to get "Putnam's void" or "Searle's void".
  • Chalmers countered that implementing computation requires that the system support state transitions that it didn't take but could have, which can't happen by assigning states to a rock (without ballooning the rock to exponential size). This doesn't apply to us then, since we reduce to a program, not a physical system.
  • There is an interesting dissonance between Chalmers and this: here we leverage the idea that lack of absolute frame of reference causes not running a program to be equivalent to running one. Chalmers instead tightens the definition of computation to avoid this sort of thing.

1. Nick Bostrom made the argument that there may be more Alices than Bobs.
2. This means we accept a "hardcoded" decompressor that takes no input and outputs Alice's universe. It is a valid representation, but not really compressed.
3. Does Quantum Mechanics say that our universe is non deterministic? No, there are QM interpretations like de Broglie hidden variables that are deterministic.
4. Can one step of the simulation really be considered the same as the decompressor? Yes, since both are fixed programs that operate unconditionally and deterministically on some input to produce some output. In fact, an RLE decompressor that constantly eats its own tail decompressing itself again and again is a possible machine Bob could have decided to run.
5. Does the previous postulate that Bob need not comprehend Alice's existence break in this case? No, since Bob is functioning as the computer, he need not comprehend what he is computing, only the atomic actions.
6. Obviously there is a difference for Bob. The simulation hypothesis presupposed Alice had a perspective.
7. I am not sure how well Python will hold up under these theoretical conditions, infinite integers should be fine, but Python is generally designed for finite machines. Should you find yourself in possession of a computer with infinite memory and infinite time, you may need to write your own Python interpreter. Sorry.
8. If you have infinite time and memory.
9. If you'd like a brief mental exercise, as shown by Schmidhuber and others, there is a more elegant way of doing this that does not require limiting each program to a finite duration.
10. An atemporal "always".
11. Imagine trying to answer the question of what % of integers are even and what % are odd. The question sounds easy at first, it's 50-50, but this is based on their natural ordering. If they can be ordered in any way you like, take the ordering 0,2,3,4,6,5... with a ratio of 2:1 evens for every odd. This means a ratio can only be found given some fixed ordering, which for the more general case we call a measure. There isn't as obvious of a natural ordering for "all possible mathematical structures", either.
12. To be specific the weight falls with 1/t. This has the effect of having a logarithmic penalty on the number of bits, meaning that universes that run for a long time are not punished as much as complex initial states.
13. Via the invariance theorem, between any two UTMs, the difference in how they weight length can be at most some fixed constant. This doesn't solve the problem though, since that constant can exceed the size of the universe.
14. Depending on how you count.