Are we living in a simulation?

I don’t mean the brain-in-a-jar (or body-in-a-pod) kind of simulation shown in *The Matrix*. I mean, is our whole universe, including our brains and minds, being simulated by some machine in some “larger” universe? Are *you* being simulated? At least, what kind of machine is capable of doing this?

## Are We Being Discretely Simulated?

Let us first consider machines that treat time discretely rather than continuously. That is, in the simulated universe, time is a sequence of moments, there’s a first moment, and each moment has a following moment. For each moment the machine stores the state of the universe, and then calculates the next state.

More mathematically, the machine runs a *discrete simulator*, which is a structure (*S*, *i*, *T*) where *S* is the set of possible states, *i* ∈ *S* is the state at the first moment, and *T* ∈ *S* → *S* is the “transformation” function, that maps the state at a given moment to the state at the next moment. Note that *S* does not have to be finite or even countable: it can be any set.

For example, we might consider moments as a very small gradation of time in our universe (perhaps the Planck time). *S* might be the phase space of the universe: the set of all possible states of all particles & fields in the universe. *T* is a function that tells the machine how to obtain the next state of the universe from the current state of the universe.

Let us say that a simulator is *feasible* if it is possible that our present universe is being simulated by a machine running it. If a given simulator is feasible, what other simulators are feasible?

It seems to me that it doesn’t really matter how a given simulator (*S*, *i*, *T*) represents the state of our universe in *S*, provided *T* works correctly. For example, if such a simulator is feasible, then these other simulators are feasible:

- (
*S*, *R*(*i*), *R* · *T* · *R*), where *R* maps the universe to a universe reflected in some co-ordinate,
- (
*S*‘, *R*(*i*), *R* · *T* · *R*^{-1}), where *R* ∈ *S* → *S*‘ performs some kind of lossless data compression of the state, and *R*^{-1} ∈ *S*‘ → *S* decompresses it,
- (
*S*‘, *R*(*i*), *R* · *T* · *R*^{-1}), where *R* ∈ *S* → *S*‘ is any function with a retraction *R*^{-1},
- (
*S* × *S*‘, (*i*, *i*‘), (*s*, *s*‘) ↦ (*T* *s*, *T*‘ *s*‘)), where (*S*‘, *i*‘, *T*‘) is another simulator (feasible or not).

In fact, all that matters for one simulator to be as feasible as another is that the state of the latter can be obtained from the state of the former. Consider two simulators **A** = (*S*_{A}, *i*_{A}, *T*_{A}) and **B** = (*S*_{B}, *i*_{B}, *T*_{B}). Then a *morphism* from **A** to **B** is a function *f* ∈ *S*_{A} → *S*_{B} such that

*f*(*i*_{A}) = *i*_{B}
*f*(*T*_{A}(*s*)) = *T*_{B}(*f*(*s*))

My assumption is that if such a morphism exists and **B** is feasible, then **A** is feasible. This is because **A** is capable of representing **B**, since for any state in **A**, there’s a function that obtains the corresponding state in **B**. So if it’s possible that a machine running **B** is simulating our universe, it’s possible that it’s running **A** instead. This seems reasonable to me.

Now consider a very trivial simulator **K** = (N, 0, *s* ↦ *s* + 1), which I call the counting simulator. Its state set is simply N, the natural numbers starting from zero. Its initial state is zero. Its transformation function just adds one. A machine running **K** is just a machine that counts.

As it turns out, for any simulator **A** = (*S*, *i*, *T*), we can construct a morphism from **K** to **A** like this:

*f* = *s* ↦ *T*^{s}(*i*)

To spell it out recursively:

*f*(0) = *i*

*f*(*s* + 1) = *T*(*f*(*s*))

For *f* to be a morphism, we need to satisfy the two conditions:

*f*(0) = *i*
*f*(*s* + 1) = *T*(*f*(*s*))

But these are exactly the definition of *f*, so it is indeed a morphism. (In fact it’s a *unique* morphism. Category theorists will recognise **K** as an “initial object”.)

So this means if *any* simulator is feasible, then the counting simulator is feasible. A simple “machine that counts” is just as capable of simulating the universe as any other.

In fact, if you want to discretise time by the Planck time, then the machine you’re reading this on, if only it could last long enough, is capable of simulating the universe from Big Bang to present day. The age of the universe is about 8×10^{60} Planck times. To represent a number this large, you’ll need 203 bits, or 26 bytes. Each number counted out by your desktop counting machine fully represents the state of a universe just like ours: it’s just encoded in a rather unusual way.

## Are We Being Continuously Simulated?

Perhaps instead the machine that simulates our universe treats time continuously. Assuming the simulation started at some point (time zero), we’ll define *Time* as the set of non-negative real numbers. The machine runs a continuous simulator (a dynamical system), defined as a structure (*S*, *i*, *T*) where *S* is a set (of possible states), *i* ∈ *S* is the state at time zero, and *T* ∈ *Time* × *S* → *S* is the function that determines how the state changes over time, with these conditions:

*T*(0, *s*) = *s* [no time means no change]
*T*(*t*_{1} + *t*_{2}, *s*) = *T*(*t*_{2}, *T*(*t*_{1}, *s*)) [the state alone determines how the state changes]

Let us make the equivalent assumption from the discrete case. If **A** encodes the state of **B**, and **B** is feasible, then **A** is feasible. Specifically, given two continuous simulators **A** = (*S*_{A}, *i*_{A}, *T*_{A}) and **B** = (*S*_{B}, *i*_{B}, *T*_{B}), a morphism *f* from **A** to **B** is a function *S*_{A} → *S*_{B} such that

*f*(*i*_{A}) = *i*_{B}
*f*(*T*_{A}(*t*, *s*)) = *T*_{B}(*t*, *f*(*s*))

By this assumption, if **A** and **B** are continuous simulators, and there exists a morphism from **A** to **B**, and **B** is feasible, then **A** is feasible.

Now consider the “clock” continuous simulator **K** = (*Time*, 0, (*t*, *s*) ↦ *s* + *t*). Its state set is time itself. Its initial state is zero. Its transformation function just adds time. This obviously matches the two conditions necessary to be a continuous simulator.

The “clock” continuous simulator plays the same role as the “counting” discrete simulator. For any continuous simulator **A** = (*S*, *i*, *T*), we can construct a morphism from **K** to **A** like this:

*f* = *t* ↦ *T*(*t*, *i*)

Let’s check the conditions:

*f*(0) = *i*
*f*(0) = *T*(0, *i*) [definition of *f*]
*T*(0, *i*) = i [first condition of continuous simulators]

*f*(*s* + *t*) = *T*(*t*, *f*(*s*))
*f*(*s* + *t*) = *T*(*s* + *t*, *i*) [definition of *f*]
*T*(*s* + *t*, *i*) = *T*(*t*, *T*(*s*, *i*)) [second condition of continuous simulators]
*T*(*t*, *T*(*s*, *i*)) = *T*(*t*, *f*(*s*)) [definition of *f*]

So it is indeed a morphism.

So this means if any continuous simulator is feasible, then the clock simulator is feasible. A simple clock is at least as capable of simulating the universe as any other machine, if only its motion is perfectly continuous.

— Ashley Yakeley