I came up with this thought experiment over the past few years. I'm not completely sure it is original, but here it is:
I will not define consciousness because I think that most definitions of it work fine with the experiment, and if yours doesn't, you'll know fairly soon. We will assume that consciousness does not imply free will (whatever that means) and is compatible with determinism. While I do believe this to be true, it is not a hard requirement for this experiment, but it makes the experiment simpler. At the end, I will go over two ways that the experiment could be modified to lead to the same conclusions even if non-determinism is true.
When I talk about a universe, I am talking about a closed system containing everything. If there are forces outside the universe not just with the potential to affect the things within, but actually affecting them, then by my definition, that is not a universe you are talking about. It would be a universe if you included those outside forces (and anything affecting them) into that universe.
When I say that "a universe contains consciousness," I will intentionally not strictly define what that means. I think your understanding of the phrase likely works with the thought experiment. If it doesn't, tell me how you understand this phrase.
Case 1:
We create a computer simulation of rules similar to those that seem to govern our universe. It has a starting state in its RAM, it applies rules and updates the RAM with the next state. We watch the simulation unfold and let's assume that we are lucky enough and eventually we recognize something very similar to human life and civilization develop in a little corner of it. Wars, love, philosophy, grief, hatred, arts, it's all there. I argue that this universe that we are simulating contains consciousness.
Case 2:
Same as case 1, but we stop and restart the experiment. Because of determinism, it will pass through the same states. I argue that this universe still contains consciousness.
Case 3:
Like case 2, but to speed things up in the second run, we use a huge lookup table as cache: During the first run, we record every state transition on a huge lookup table, with the current state as a key and the new state as a value. On the second run, we do not need to apply the actual rules of the universe anymore; we can just keep looking up the result of the calculations in our lookup table. The RAM passes through the exact same sequence of states, so I'd argue that this universe still contains consciousness. If you believe that actual calculation is required for consciousness to arise, consider that your CPU already uses microcode and lookup tables for many calculations, and some programming languages memoize results of stateless functions. So, even when you think you are calculating, you are actually using a lot of look-ups in caches and pre-computed tables - I'm just expanding this principle. A lookup is no less of an algorithm than any other algorithm that you run so philosophically I see no difference if the lookup brings the same results as the supposedly "proper" calculation.
Case 4:
Like case 3 but instead of keeping the cache as a lookup table with keys and values, we realize that each value is also a key, so we store the table in a compressed form where instead of:
a→b
b→c
c→d
We store:
a→b→c→d
We use that structure as a way to avoid doing the actual calculations. The RAM passes again through the exact same sequence of states, so I argue that this universe still contains consciousness.
Case 5:
Like case 4 but after the first run that populated the cached states, we went manually through all of them and replaced each cached_state with f(cached_state) where f is a reversible function (i.e., there is a 1-1 correspondence between each state and its transformation through f). Since no information is lost, even though the RAM passes through different states than the first run, those states are equivalent to the states of the first run and consciousness must still be contained in this universe. After all, if the computer used Big Endian or Little Endian or a different but equivalent floating point standard where the mantissa is stored before the exponent, it shouldn't really matter to the emulation. Indeed, our computer's current representation is just one of an immense number of possible representations - if changing to another representation could break consciousness, we should be equally concerned that we're already using the wrong one.
Case 6:
Like case 4 (not case 5) but we manually went through every state in the cache and removed the information describing a part of the universe far away from the civilization, one that the civilization never interacts with. I argue that since the RAM otherwise passes through states that show exactly the same civilization evolving, there is still consciousness in this universe, despite a far away part missing.
Case 7:
Like case 6, but the part of the universe that we exclude from the cached state is one that interacts with the civilization. Let's say we removed the moon of their planet. By "remove" I simply mean that the RAM no longer contains information about the moon itself, while the rest of the universe is intact as if the moon still existed: we still see bodies around where the moon should be being gravitationally attracted to it, we still see humans walking in the moonlight, we still see their moon missions going there and coming back with stones. We just have no part of the RAM in the simulation that actually contains the info of what is going on exactly there. In fact, when simulating physical interactions at a very low level, in some cases we may be able to ignore particles that we know cannot interact with other particles until some moment in the future, instead of calculating their position at every moment in time until that interaction. If the rules are elaborate enough to allow for this skip in time where individual particles do not get tracked for a while, what is the problem with coming up with an elaborate rule (the lookup table we created in case 3 is one such very elaborate rule) that allows us to calculate the evolution of a civilization on earth without actually keeping track of the moon frame by frame and only keeping track of the effects it has on earth? I argue that there is still consciousness in this universe.
Case 8:
Based on case 7 and case 5, I conclude that any transformation of the states of the cache that we initially introduced in case 4 does not remove the consciousness from this universe on the second run (the one utilizing the cache) as long as consciousness remains recognizable in the transformed states. If that is the case, then a kind of 2D video of the universe is also one such transformation as long as it shows enough of the civilization to keep consciousness recognizable, and therefore playing back that into the RAM during the second run will mean that this universe still contains consciousness. One might object that a 2D video loses too much information by collapsing a 3D world into a 2D projection. However, consider that instead of removing the moon, we could remove every odd cubic millimeter of the universe from our cached states. The lookup table was created from a full-scale simulation, so even though we're not storing the state of those odd cubic millimeters, their effects are still perfectly captured in how the rest of the universe evolves. If consciousness survives this kind of spatial sampling while the causality that produces it is maintained through our lookup table, then a 2D projection is just another way of encoding the same causal relationships while being selective about what detail we maintain in RAM.
Case 9:
Like case 1 (not case 8) but this time instead of keeping each state of the universe in the same position in the RAM, we don't really use a RAM, we use a write-once memory, so each state has to be written in adjacent locations that can never be erased. I argue that this matters not and is an implementation detail, the universe still contains consciousness.
Case 10:
Like case 9 but we rerun the simulation on the same write-once memory. Due to determinism it would attempt to write the same things in the same locations, but the data is already there so all write operations become no-ops. This brings us to a weird conclusion: A system where the only thing that changes is a register pointing to the current state of the universe (the "now" in the simulated universe) while everything else is static (no changes in the main memory) is still capable of simulating a universe that contains consciousness.
Case 11:
Like case 10 but since the "now" pointer is not really interacting with the universe simulation in a way that has measurable results, we move this pointer to a different computer, and just watch the two computers in operation, one computer containing all the states of this universe, while the other computer fetching from the first computer every state, recalculating the next state and throwing away the result. I do not see any functional difference so these two computers together are simulating a universe that contains consciousness.
Case 12:
Like case 11 but since the results of the calculations of one of the computers are thrown away, we might as well not calculate them. After all in case 3 we decided that not calculating stuff and just looking up the pre-calculated result in a cache is fine, so the calculation itself is not magical in any way. If you somehow knew the previous value of a memory location and chose to only flip the bits that needed to change, rather than erasing and rewriting all bits, you wouldn't say that consciousness was lost. Well, in this case we know that no bits need to be flipped at all, so skipping the calculation entirely is just another optimization. But now the computer with the stored states is equivalent to a tape, or a DVD, as these also contain all the states in sequence, separated physically in your universe. The computer holding the counting pointer is equivalent to a counter circuit or a clock.
Conclusion?
I have a DVD with a documentary, and I have a clock, and they are no more interacting with each other than the two computers in case 12, so... does that mean that the DVD, even when not played in a way creates or contains a universe that contains consciousness? One might object that the DVD wasn't created through the careful process of running a full universe simulation and creating a lookup table - it's just a recording of 2D projections of our universe. However, this objection leads to a paradox: If we actually did make a full simulation of another universe and then modified the lookup table to turn it into a DVD that happens to be bit-for-bit identical to an existing documentary DVD (no matter how improbable such a match would be), would one DVD contain consciousness while the other doesn't, based solely on how each was created?
Further implications:
Pushing even further from our DVD plus clock conclusion: we noted that the clock in case 12 doesn't actually interact with the data - it merely marks a theoretical progression through the states. But if the clock's interaction is purely theoretical then any potential way of traversing these states serves the same purpose. Even imagining the progression through these states would be equivalent, with your brain acting as an over-engineered clock/counter. This leads to an even stranger possibility: if we could imagine a projection that matches, state by state, what would be produced by the careful simulation process described earlier (however improbable such a match would be), would that imagined projection also contain consciousness, and does our imagination therefore create separate consciousness from our own?
Non-determinism:
If you consider determinism a limitation in the above experiment, there are two ways to incorporate non-determinism without changing the experiment's conclusions.
The easy way:
If all the non-deterministic random choices that will be taken by the universe could be included as a blob of data in the initial state of the universe, then non-deterministic universes could be treated as deterministic universes that include a "seed" for their randomness in their initial state, and that seed could be non-deterministic itself, as an inconsequential exception to our rule about universes never interacting with outside forces. After all, the rules of the simulated universe are decided by us, in our universe, so deciding a seed, deterministically or not, to make the simulated universe effectively non-deterministic is not breaking anything in the thought experiment.
The messy way:
If the simple solution doesn't satisfy you, perhaps we can consider all the possible paths that a simulated non-deterministic universe can take as a tree. We can still, in theory, calculate all of them and populate the cache of case 3. We can still convert the cache into a form of a branching, tree-like tape like the one in case 4. We can still modify the "frames" in this tape as described in cases 5 to 8. And we can still lay out the states physically separated in different memory locations instead of overwriting the same location as in case 9. In fact, it may even be more natural to lay them out in space depending on whether we chose depth first or breadth first or something in between when calculating (or looking up in the cache) the next state(s) of the simulated universe. In general, all the cases still apply just fine if the shape of the simulated timeline is a tree, and not really a line. And if at least one path from the root to the leaves contains a human-like civilization, I'd argue that the simulation contains consciousness.
