This is the second part of the Pitless Pit series. For your convenience you can find other parts in the table of contents in Part 1 — Furmanek Test for consciousness

Do we live in simulation? I don’t know. I don’t know how to prove it either, especially that I can’t ever disprove solipsism. However, we can imagine what it would take to simulate a universe, and then reason whether it’s feasible or not.

First rule of simulation

Historically, we experiment with any kind of simulations for two reasons:

We want to experiment with something “new”. For example, we create esoteric programming languages to check how stronger type systems would perform with “real” code. We don’t focus to squeeze highest performance, but we want to run the simulation once, validate or disprove our hypothesis and then move on to something else.
We want to represent something from the real world and run it faster to get some meaningful results that would help us shape the future. In this case, we want to run the simulation multiple times, so we want to make it fast and performant.

It seems reasonable to assume that if we live in a simulation, then that they who simulate us are doing the same. If they want to experiment with something “new”, then we probably can’t deduce anything from our world.

However, if they want to represent the “real world”, then they’ll probably want to be efficient. This leads to the first rule of simulation – the time needed to generate the next simulation step should have a constant upper-bound. In other words, once we simulated the “current” state of the simulation, then we should know upfront how long it will take (in the worst case) to simulate the “immediately next” state of the simulation.

Let’s now assume that they go by the first rule of simulation. What does it mean in practice?

How to simulate our universe

Let’s now think for a second how we can simulate our universe. It seems that the simulation must be discreet, i.e., it must proceed in steps. Therefore, we would have a code like this:

var state = getInitialState();
for(var step = 0; ; ++step){
    state = generateNextState(state);
}

var state = getInitialState();

for(var step = 0; ; ++step){

state = generateNextState(state);

}

If the first rule of simulation holds, then generateNextState‘s execution time must have an upper bound. Let’s now consider how it could be implemented to simulate our universe:

Iterating over every point in space-time (assuming that it’s discreet) probably won’t meet the rule. We believe our universe expands, so each iteration would need to go over more and more coordinates. This would work if the size of the universe was constant, but we don’t think so as of now.
Iterating over particles won’t work either, as the number of particles changes.
Iterating over “energy” or “electric charge” or similar things might work, though. As long as these things are ultimately traveling in packets, we can iterate over every single packet and track how it evolves. This seems to be a feasible approach to simulation.
Representing the state as a polynomial (or other formula) with fixed number of coefficients might work as well. We could the generate the next state of the simulation by feeding the output of the previous calculation through the formula, similarly to what recurring neural nets do.

It seems there should be possible ways to simulate the universe. We can now draw the following conclusions;

If we are able to prove that some approach indeed works, then we probably should assume that we live in a simulation.
On the other hand, if we can prove that these approaches don’t work and there are no other ways to do that, then it would prove that we do not live in a simulation.

Can we prove or disprove any of the above? That seems to be unclear yet.