Next: Proof Two Up: The Pandeist Theorem Previous: Proof One   Contents

## Example: Partitioning a Finite Binary String

If you are not at least a bit of a mathematician, you are probably not happy with the proof above because you don't understand it. The idea of ``information'' or the ``state'' of a system may seem very abstract. To illuminate the situation, let's consider a very, very simple ``Universe'' where you can count up the difficulties that illustrate the point a case at a time, and then extrapolate this example to the general case, where without exception the difficulties we encounter will be much, much worse!

Information theory is often applied to the encoding of a message in binary, so let's consider a very small binary Universe. It has a very small number of possible states, only one of which we will consider to be ``existential reality'' and hence ``the message'' that we seek to know. The information in a single such string is incompressible and irreducible - every bit is necessary to communicate the message as there is no metric of ``closeness'', only identity or non-identity. In the case of Universes, of course, there can only be precisely one if there are any at all. Let's look, then, at what happens when we partition a simple, irreducible binary string with a handful of bits as a Universe into two pieces.

At first glance this example seems inadequate - what about processes, consciousness, free will, awareness, abstract knowledge, and all that? However, it turns out that we can use our imaginations to do away with all of them. All of them, note well, involve time, involve a sort of ``doing'' in a system that changes from instant to instant. However, we can completely ignore time in our meditations, as the time that events occur in the real Universe is just more knowledge, more data. The Universe itself is ``timeless'' - it is the union of all things that actually exist not at any particular place and time but at all times and places that themselves actually exist. We can therefore completely ignore the dynamics of ``reason'' in general - sequential operations performed on data - because the operations themselves will necessarily have a description to differentiate them from all other possible operations and sequential orderings and that description is still more data.

Ultimately, you can then think of the Universe in all of its dynamic glory - all places, times, dimensions hidden or otherwise, and ``stuff'' therein that has objective being - as being a really, really, large (possibly infinitely large) DVD recording: a binary string. When time is a part of the data on the DVD - the part that makes the movie ``happen'' - the DVD itself becomes an abstract timeless set of data, and God (if God exists) must both be a part of that data and somehow encode on the part that is It the data that is all of the rest.

Instead of ``information'', then - which seems rather abstract - we will consider data, as we have plenty of concrete experience with data in the context of computers, and every schoolchild with sufficient mental capacity learns about binary numbers by the time they are in high school. We don't need to think of a particularly long binary string, because we can always imagine making a quite short one longer, and longer, and longer (without bound) in one of the time-honored methods of imagining infinity, as long as we get some idea of how the other quantities we shall discuss scale up as we do so.

Let's let our Universe have only eight such bits - enough to illustrate the problems and yet easy to count. We can then write a possible state of this tiny Universe as: 01001001. Our representation is not unique, of course. This bitstring is perhaps more easily recognizable as the decimal integer 73. The point is that all knowledge of this teensy, finite Universe has to be self-encoded. There is no ``outside'' we can use to store additional knowledge such as bit location or a rule connecting the value of the fifth bit to the value of the second bit - to encode that we would have to adjoin more bits onto our bit universe, and then we'd have to adjoin still more bits to specify how to decode the encoded information, and... all of this can, actually, be handled (and thinking about it and handling it is part of what theoretical computer scientists and number-theoretic mathematicians and mathematical philosophers do) but as I said, including it all simply makes things worse from the point of view of this theorem as the Universe will forever be chasing its own tail, trying to encode how it encodes its previous metaphysical level of encoding on the next one, and then discovering that now that is an abstract string of binary data with no a priori necessary secret decoder ring.

Now let us partition this bitstring into a small piece (the non-God part) and a larger piece (the God part): 01001001 where I will boldface the non-God part just so that we can keep track of it below. For purposes of illustration we'll place the non-God part on the left, but bear in mind that we could have selected any two bits to be non-God, or equivalently there is already information being encoded outside of our system when I perform the partitioning in this way and we'll have to account for this information later.

In this particular case, from the outside (which we usually would like to call a God's eye view, only there is no outside to the real Universe where God could perch to obtain such a look) we can easily point to a bit string in the God part (which I will do with ()'s) such as 010(01)001 or 010010(01) and say ``Aha! Look! God knows about non-God!'' simply because we see the naked bitstring recapitulated in God somewhere. But this isn't quite right. Consider the following four possibilities:

00001001
01001001 (!)
10001001
11001001

If we consider separately what God knows:

001001

it certainly doesn't seem to contain any information that uniquely specifies which of the four possibilities listed is the actual one and only existentially unique Universe. It is just the number 001001 = 9, after all. It is simply not a profound metaphysical truth that the number nine uniquely implies the number 01 = 1 (or the more informative number 01000000 = 64) due to some self-encoded rule11 buried in the number 9!

All four of these seem to be possible Universes from the set of all data Universes that have eight bits of information. If we restrict our one actual existential Universe 01001001 to the smaller sub-Universe 001001, we introduce entropy into the reduced description. We have lost information - even though we can indeed identify fragments of the latter that correspond to the former, they are information about the latter in and of themselves and we need a higher level set of rules to identify the particular bit fragments that we omitted. God cannot really be said to ``know'' all of 01001001 unless God is 01001001, as only in this case is all of the information required uniquely specified in God!

To make it completely clear, our original Universe could just as easily have turned out to be 11001001 so that 11001001 describes non-GodGod. In this specific case there is no bit string 11 in God. We'd have to use something like 1100(1)00(1) to ``discover'' that it is there, or invent another rule such as 11[00]1001 where []'s mean ``select these two bits and invert them to get non-God's state value''. Our ruleset instantly vastly increases in size as we've introduced selection and bit inversion in any permutation, allowing us to encode any bit combination (in either order) in non-God as any two bits (in either order) of God. Either way, things are getting quite complex and we should feel increasingly uncomfortable about the arbitrariness of these rules and the bald fact that there are many possible rules that could give us a connection but nothing in the string 001001 itself to give us any hint of which rule we are supposed to be using to somehow ``uniquely decode'' 11 versus 01 from the contents of God alone in order to consider it to be legitimate ``knowledge''. The decoding rules simply aren't there, and even if we adjoin them somehow they won't be unique!

Entropy is shifty stuff. If we start with two disjoint strings 01 and 001001 and imagine that we have somehow discovered a unique decoding rule buried in a (much larger, obviously) bit string, we then have to consider all of the ways we can combine the two strings because there was nothing special or resolvable about having the former on the left of the string on the latter, or even having them unmixed! All of the following are possible ways that the same data could be ordered in the actual Universe, given only the binary information inherent in each placed into an eight bit Universe of possibilities:

01001001
00101001
00011001
00011001
...
00101001
00011001
...
00100101

Looks like we need to consider all the permutations of bit order and I'm being generous here and still leaving both bitstrings in left-right order although once we start putting the two together even relative bit position becomes additional information required to specify the particular ``decoding'' of the two separate entities from knowledge of only the God part 001001 into the actual unique existential Universe 01001001 compared to any of the other permutations in our Universe, where bit order is ``knowledge'' of the whole and hence matters..

Even this is not enough. Once we step outside of the God part, there is literally no limit on the number of ways to transform the number 9 (in binary or any other representation) into the number 73 (ditto). It is not only infinite, it is a scary infinity, one that blows up as fast as you imagine any part of it. There is (perhaps) some minimal number of bits required to encode a ``secret knowledge decoder ring'' that precisely gives you two-bit not-God from six-bit God, but it isn't six bits, there is obviously no maximum number12 and finally there is neither time nor process inherent in this ``God's Eye View'' of the essentially stationary Universe where we've ``unrolled'' all temporal sequences into an aggregate of events, into merely static ``data'', so that decoding itself cannot really occur as it is a transformative, sequential process13.

Hmm, looks like our simple, binary string was hardly simple after all! After all, the Beatles also had Revolution One on the same album as Revolution Number Nine, and perhaps - just perhaps - this is the correct encoding/decoding of God vs non-God in our tiny existential Universe. This doesn't seem very plausible, of course, and it is precisely this sense of plausibility that you need to encourage in yourself to grasp the point of the theorem above.

Obviously, our binary representation of a data Universe can be extended by adding as many bits as we like to both the God and non-God partitions without changing the conclusions of the argument. As long as the non-God part of the Universe possesses any conceptual variability, the God part certainly can contain data and can contain encoded rules that with a suitable external decoder and process can transform that data into a match for the non-God part, but the only way to know if the result matches is to look, because one can always imagine the same right hand part conjoined to any of the possible left hand parts. ``Looking'' here is impossible, as we've eliminated time and interaction and really the possibility of external data transformations using data-encoded rules. Only when the God and non-God parts of the system and the decoder are all part of a single static view of the Universe can that Universe be said to be ``perfectly known'' (lack information entropy) and only if God is the whole Universe can it be said that God is a zero entropy God, missing no information concerning the state of the Universe, exists. Partitioning is still possible, relative entropy can exist, ``process'' can exist in the form of global patterns in the static Universe, but one cannot point to any strict subset of the Universe and say this part is God and still perfectly knows all about the Universal complement of that part - everything else.

Next: Proof Two Up: The Pandeist Theorem Previous: Proof One   Contents
Robert G. Brown 2014-02-06