Let’s start with the following assumptions:
It should be noted that these are observable assumptions, and as such, they cannot be definitively proven. However, the observational evidence supporting them is strong.
The first assumption posits that the human genome encodes all the information required to construct a conscious, pain-sensitive human being within this universe and its observed laws of physics.
The second assumption states that DNA is composed solely of ordinary physical matter. It is made of the same matter as everything else and is governed by the same physical laws, with no non-physical or supernatural influences affecting its operation.
It then follows that humans, unlike what Roger Penrose speculates, must be implementations of axiomatic systems. Consequently, consciousness can be described using the principles of mathematics.
Let us make a third assumption:
It states that all physical processes can, in principle, be simulated by a device known as a Turing machine. Modern computers are essentially Turing machines. The Church–Turing Thesis has never been formally proven, but if it were false, we would have good reason to worry about keeping our money in bank accounts.
From these three assumptions, it follows that humans can be simulated by a Turing machine—or, in its modern incarnation, a computer.
Suppose we digitize a human genome and run it on a computer simulating a universe governed by the same laws of physics as our own. As the simulation executes, the DNA evolves into a conscious, pain-sensitive observer. The simulated human experiences an expanding universe where time flows from past to future, and tooth pain is real.
All software programs consist of two kinds of information: code (c) and data (d). In a DNA simulation, the code would describe the laws of physics, such as quantum mechanics and gravity. The data would include the digitized DNA and a sufficiently large section of the surrounding universe. Let us assume the simulation software consists of a roughly equal amount of code and data.
A well-known technique for optimizing slow, CPU-intensive code is to use lookup tables, which replace computation with precomputed data. For example, one can replace all sqrt() computations:
result = sqrt(arg);
with precomputed values:
result = sqrt_lookuptable[arg];
Empirically, software programs yield identical results regardless of how the result was computed. 2 + 2 = 4, and it does not matter if we replace all 2 + 2 equations in our code with a precomputed value of 4. This optimization therefore cannot affect the simulation’s output, nor the observer’s experience of time or pain. Delaying or accelerating computation affects only the external runtime, not the internal state transitions of the simulated system.
However, this optimization has the effect of reducing the amount of code and increasing the amount of data in our DNA simulation:
Now, imagine we gradually optimize the DNA simulation by replacing algorithmic components with lookup tables. As a consequence, the number of CPU cycles required to run the simulation decreases. Suppose we take this optimization to the extreme: all computation is replaced by a static dataset encoding the entire execution trace.
As a result, we don’t have anything to run on a computer. It is just a massive hard drive of data.
Does the simulated human still experience time and pain?
The answer, within the axiomatic model, is yes. Affirming otherwise would certainly imply the existence of a new physical constant in our books of physics: a minimum code-data ratio required for consciousness to emerge.
As such a constant would contradict the initial axioms, the temporal structure and pain, therefore, must emerge from the internal relationships among states, not from the external runtime. From the internal perspective of the simulated observer, time still flows from past to future and pain is real.
In conclusion, a static dataset can fully specify a universe containing conscious observers with subjective time. Consequently, time and pain must be properties of simulated observers, not fundamental properties of the universe.
When a single DNA simulation—let’s call her Alice—runs on a computer, the execution trace is easy to study. Every CPU instruction drives the computer (and Alice) to a new state. From Alice’s perspective, time flows forward, and the effect of each CPU cycle can be mapped to a simulated particle in her world.
However, consider a system running multiple DNA simulations concurrently—say, Alice and Bob—where thread scheduling is governed by quantum randomness. The resulting execution trace interleaves their simulated lives in segments of unpredictable length.
Since both single- and multi-threaded computers are computationally equivalent, each observer must experience a coherent, continuous timeline.
Now, let’s gradually shorten the number of CPU cycles until each thread is limited to running a single CPU cycle before switching. Let’s also add more DNA simulations, like Robert, John, and Jill. As the number of concurrent simulations increases, the execution trace becomes increasingly fragmented. Additionally, modern multi-threaded systems often include many extra threads for operating system tasks, such as listening for network requests. This injects fragments of irrelevant data into the execution trace. In the limit of infinitely many perfectly interleaved simulations, the execution trace approaches pure white noise.
Is Alice still conscious?
The answer, again within the axiomatic model, is yes. Empirically, multi-threaded computers function reliably regardless of how few CPU cycles are allocated per thread switch or how narrow the CPU’s internal registers are. From each observer’s internal perspective, time still flows from past to future.
This raises an obvious question: how does Alice know which sequences belong to her and which do not, in order to remain conscious?
Conclusion: if there is any way to interpret static noisy data as a “conscious observer,” then that is exactly what happens: a conscious observer emerges. If the initial assumptions hold, consciousness, pain, and subjective time can emerge from static data that resembles pure static noise.
This idea fights against common sense. One might think that virtual universes only come into existence when a simulation is actively executed—that the computer must be powered on to run the simulation code for the simulated world to exist. If the simulation computer is never started, it seems obvious that no simulated virtual world emerges: no consciousness, and certainly no pain.
However, static data (such as the full execution trace of a simulation) has no inherent notion of time. There is no external reader stepping through the data in any particular order, like from left to right. Modern disk operating systems also physically scatter data across the hard drive in no particular order.
We cannot touch the virtual objects in those simulated universes. We cannot measure the distance between our computer and the simulated particles. We cannot measure the time it takes for the “execution” to create the virtual world. One cannot argue that one created the other. What appears as static information (e.g., the execution trace of a computer) to us external observers appears as an expanding universe and conscious experience to the simulated human observing the data from within. This relationship is representational, not causal. The computer and the simulated universe are two sides of the same coin: distinct arrangements of the same information.
And there are more than just two sides on the coin. Consider an execution trace of N bits. These bits can be arranged in 2N ways. Apparently, most of them describe chaotic universes with no conscious observers. One, however, describes our identical simulated twins—Alice, Bob, and others. And one describes something we call a computer, which is simulating a computationally heavy procedure—DNA.
Philosopher David Chalmers [2] proposed the concept of a philosophical zombie: a hypothetical being that is physically and behaviorally identical to a conscious human but lacks any subjective experience. Such a zombie would respond to pain stimuli in the exact same way a conscious person does—it would cry out, flinch, and try to avoid the source of pain—but it would not feel anything.
According to Chalmers, even with a perfect simulation, we would only be observing the physical processes. We still wouldn’t know if there’s a “ghost in the machine”—a feeling of what it’s like to be that simulated being. A computer could be programmed to perfectly mimic the behavior of a person feeling pain without actually having the experience itself.
Let’s make a fourth assumption:
This assumption brings the concept of pain from philosophy to physics. Just like gravity, pain is assumed to have observable consequences that are physically detectable and measurable. Formally:
If a system’s behavior is entirely determined by its physical components and their interactions, an axiomatic copy should exhibit identical behavior. If their behavior is identical, then their internal states, including consciousness and pain, must also be identical. 2 + 2 = 4 holds for both bananas and apples. If the original’s behavior is driven by the experience of pain, the simulation must have that experience too. Otherwise, there would be a contradiction.
Correspondingly, the P-Zombie is an impossibility. If Axioms 1–4 hold, the P-Zombie premise collapses:
While full-scale DNA simulations are currently beyond our computational reach, this limitation is secondary to the theoretical framework. Much like our inability to calculate the highest possible prime numbers, the current technical ceiling does not invalidate the underlying logic; what matters is that such simulations are possible in principle.
As soon as computational technology allows for high-fidelity biological modeling, we will be able to test whether a simulated human truly experiences subjective states, such as pain. This provides a clear path for empirical validation. We can simulate a statistically significant sample of human subjects and study their behavior via monitors, exactly as we play virtual games. This time, however, the avatars in the game are fully self-contained simulated copies of us. By comparing the simulated subjects’ responses to those of their real-world counterparts, we can measure the difference. If the simulated subjects exhibit the necessary biological reactions but lack the qualitative experience (qualia) of pain, their behavior should be different compared to us humans. Should this be the case, the arguments presented here collapse. This would indicate that at least one of the four initial axioms is invalid.
One might argue that replacing code with precomputed data does not truly eliminate computation. The computation simply occurred earlier, when the lookup tables were created, and therefore the optimization argument collapses: static data alone would not be sufficient for subjective experience.
This objection fails for the following reason.
Software is fundamentally order-critical. The sequence in which elementary operations are executed is essential. Swapping the order of even relatively simple operations often destroys the correctness of the program entirely. In a system as complex as a full-scale DNA simulation, changing the execution order would almost certainly crash the simulation or produce complete nonsense instead of a coherent Alice.
However, when we precompute lookup tables, the order in which we calculate those values is largely irrelevant to the final result. What matters is only that the precomputed values correctly correspond to the inputs they will receive during execution.
In other words: the temporal order in which the programmer (or the optimizer) computes the lookup tables does not need to match the order in which those values are later accessed. The final static data structure encodes the correct mappings regardless of the history of its creation.
Thus, the optimization process remains valid. We can gradually transform a fully running, causally ordered simulation into pure static data while preserving the exact output. If subjective experience depended on the real-time execution of those precomputations, we would require some form of metaphysical or non-computable process to explain why the experience survives the optimization. This would directly contradict Axiom 3 (that all relevant processes are computable).
The optimization argument therefore stands: subjective experience can persist in purely static information.
If the four assumptions hold, then the following conclusions follow directly:
Should future high-fidelity simulations of humans show no subjective experience despite matching all measurable behavior (including pain responses), at least one of the four initial assumptions would be falsified.
Until such counter-evidence appears, we assume the four axioms hold, and summarise them under one principle:
Principle 20.9.1: Internal Emergence Principle (IEP)
For sufficiently large information content, the space of possible bit configurations inevitably contains arrangements whose internal structure gives rise to consciousness, subjective time, and pain.