Can we use a result from Quantum mechanics to prove we’re living in a simulation?

Is it really possible that we are living in a simulation?

Here we provide one piece of evidence that lends support to the idea that we are in fact living in a simulation. It shows how the “source code” for a simulation would likely use a certain design concept that just happens to perfectly explain the mysterious (and currently unexplained) “measurement problem” in Quantum Mechanics.

The Measurement Problem in Quantum Mechanics

The measurement problem in Quantum Mechanics (QM) is legendary for being mysterious and unintuitive. As one physicist famously said, “If you’re not completely shocked by the measurement problem in QM, then you don’t understand what it is asserting”.

In essence, the measurement problem shows that reality doesn’t exist until someone observes it. Or, more precisely, it is the act of observing an event that causes reality to transition from a set of probabilities into an actual fixed state. This is known as the “collapse of the wave function”.

You might say “Well, it’s because you observed it with a flashlight, and the light particles influenced the result.” But scientists have gone to great lengths to eliminate these kinds of variables, and they have shown that it is simply the act of “observing” the result that causes the collapse.

This is a bold and hard-to-believe assertion, and it is what the previously mentioned quote was referring to when it said if you aren’t shocked by it then you don’t understand it. It is indeed shocking - it says that the act of observing something influences the physical properties of our reality. It almost feels like we’re veering into the supernatural.

The obvious next question is - what constitutes an “observer”? Is a cat an observer? What about an ant? A plant? These questions are difficult - probably impossible - to answer.

Shut up and calculate!

The measurement problem is so mysterious that several different schools of thought have arisen in an attempt to explain it. There’s the “Copenhagen Interpretation”, the “Many Worlds Interpretation”, the “Consistent Histories Interpretation” – and many more. And the most popular one - the Copenhagen Interpretation - basically boils down to “we don’t really know why it works this way, it just does”.

One thing that scientists do agree on is that the math is unassailable. Over decades of research and real-world use, the formulas that govern QM have consistently been shown to be correct, regardless of what the underlying explanation is. “Shut up and calculate!” is a phrase coined by physicists to illustrate the fact that we know the equations work even if we don’t know why.

Source Code for a Simulation and JTE

Now let’s move on to the simulation. If we do live in a simulation, then there must exist software to run it. This is the “source code” that makes the simulation run.

There is a concept in software design called “just-in-time” execution (JTE). The idea behind JTE is that you want to postpone running code until the last minute - i.e. only when it’s actually needed – or, “just in time”. This is a common optimization used to reduce the amount of code that needs to run.

For example, suppose you were designing a game that allows players to visit distant planets in other galaxies. The details about the planets – the size, the landscape, the weather, the wildlife – is randomly generated. There is an algorithm to generate the details, and it uses a random-number generator so that every planet is different.

When a player stumbles upon the location of a new planet that no other player has discovered, the planet does not exist yet - only the algorithm to create it does. Then, at the last minute, when the first player arrives, the JTE code runs the algorithm to create the new planet. If a second player then discovers this planet, it will be exactly the same as it was for the first player. So, once a planet is created, it is permanent, and all players will see the same planet.

I think it is safe to say that if we were writing the code for a simulation, we would use the JTE optimization to ensure we weren’t running unnecessary code. No need to render a tree in the middle of a forest if there is nobody around to see it.

So what does this prove?

Now let’s pull these 2 concepts together. If the software for a simulation uses JTE, then it would appear to people inside the simulation as if reality doesn’t exist until someone first needs it – i.e. someone observes it. And once it is observed, from then on it is the same for everyone.

In fact, JTE is a perfect explanation for the measurement problem in QM. This is especially notable in light of the fact that there are no real alternative explanations – as noted earlier, the measurement problem has many interpretations, but no satisfying explanation. JTE is a perfect explanation.

Now, the logic that takes us from the statements above to the claim that we are indeed living in a simulation is tenuous. We can’t claim that A implies B. We can only claim that there exists a currently unexplained aspect of B that is perfectly explained by A.

There are only a handful of “unexplained” phenomena in our world. The measurement problem is one of them. So finding an explanation for it is significant.

Is it enough to prove we are living in a simulation? No, but it’s close.