## Thursday, December 12, 2013

### Truth Tables

Summary: There's a short program that can run all possible programs, OMG

Alternative Summary: Just about any universe that can exist must contain ours, OMG.

I was thinking about diagonalization arguments. Does this make any sense? Can anyone debug it for me?

# Self Evident Truths

The universe is computable.

All computations can be performed by Turing Machines.

The mind is made out of atoms.

The name of the empty string is epsilon.

# Truths

Binary Strings are enumerable : epsilon, 0, 1, 00, 01, 10, 11, 000, ....

There's a way of converting binary strings to Turing machines and back again. It gets all Turing machines.

# Consequence

Consider tables TT(n), which are numbered by binary strings along the top and side, representing turing machines and inputs respectively.

Construct a series of finite triangular tables which are defined iteratively as follows:

## TT(1)

To construct the first table, we need one element, the top left, which corresponds to the turing machine epsilon working on the input string epsilon.

Convert the string epsilon to its corresponding turing machine, which has no states and no transition rules, and which therefore halts immediately without accepting.

The value of TT(1)(epsilon,epsilon) is therefore F0 (Fail after no steps).
` `
```    eps
eps F0 ```

That's it for TT(1).

## TT(2)

TT(2) will have three cells, the topleftmost three

To construct the second table, consider again the element at the top left. Since it represents a halted state, copy it verbatim from the last table.

Then consider the element corresponding to (epsilon,0) , or  row epsilon, column 0, or (TM(epsilon), "0")

Again TM(epsilon) is either a machine with no states, or an invalid specification, and so it halts immediately on the input 0.

For the third step in constructing the second triangle, consider (TM("0"), epsilon).

TM("0") is another dud. It halts immediately without accepting.

So TT(2) is the table

`     eps 0`
`eps  F0  F0`
`0    F0`

## Towards Infinity...

It should be reasonably clear how to continue the construction of these tables

For instance TT(3) looks like

`     eps 0  1`
`eps  F0  F0 F0`
`0    F0  F0`
`1    F0 `

Eventually we will reach a row whose string represents a TM which does something other than halt immediately without accepting.

As an example of what to do then, consider the string 1001111, which is the 207th string.

In the usual encoding, this string will represent the TM with start state 0, and transition function delta(0,B)=(0,0,L).

The first time we consider the 207th row will be when we calculate TT(207), the 207th triangular table.

The first cell we consider in that row will be ("1001111", epsilon). Since 1001111 represents a valid machine, we construct the Instantaneous ID (epsilon,0,epsilon), which represents a machine in state 0 with a blank tape.

That's the value of TT(207)("1001111",epsilon).

When we construct TT(208), we take that ID from TT(207), and execute one step.

In this case, the machine head moves one step left, writing a zero, and so the instantaneous ID becomes (epsilon,0,0) (State zero, tape reads ...0...., head just to the left of the zero)

And so on. The values of TT(n)("1001111",epsilon) are undefined for n<206, since the tables are not that large, but for n=207 onwards, they are:
(epsilon,0,epsilon), (epsilon,0,0), (epsilon,0,00), (epsilon,0,000), and so on, with the tape head moving ever leftward, leaving a run of zeros behind it.

Other strings may represent TMs that do things that are even more interesting.

## But Not Beyond, (Or Even As Far As)

As we construct the successive tables, they become larger and larger.  Some cells will stabilize after a finite number of steps, either accepting or
rejecting their input strings, at which point their contents become
either F??? or A??? where ??? is the number of steps taken.

Some cells will loop. By comparing the instantaneous state of the table with the state of the cells in all previous tables, loops can be detected. We can mark them as loops, continue computing as before, or re-use the values in the previous tables to avoid performing the computations again.

And some cells, like the ones at ("1001111", epsilon)  will keep producing new instantaneous IDs, without looping.

But every TT(n) is a finitely computable object. Indeed the program to compute them all is very short and will run on any computer worthy of the name.

## I Find This A Bit Worrying, Because:

As we continue to construct the successive tables, we will perform every conceivable computation.

We will simulate in precise detail every possible world, universe and multiverse. Even though our computer is not quantum, we will simulate all quantum computations.

In particular, if you believe that you are a computation, or that simulation of your brain is equivalent to your existence, then you will be present in the computation, with exactly as much free will, and with your behaviour as precisely determined, as it ever was or will be.

Some of you will live in universes in which artificial intelligences rise and successfully paperclip everything.

Some of you will live in universes where friendly AIs are built, if that is possible.

It will not be possible for these copies to tell which copy they are, and so they will not be able to tell what is about to happen, or what has happened. Any more than you can.

There will be hells and paradises.

In some universes, copies of you will set programs running to calculate the successive triangular tables TT(n), and they will keep adding memory to their computers as needed (only actually one extra storage location per step of computation, at worst).

And so the sequence of finite truth tables will contain itself, as well as everything else. Everything that has ever happened will happen again. You will be reborn and live and possibly die. You will not know whether you are in the 'base universe', or in the computation. If that even means anything. And every computation that occurs as part of this great computation is utterly "Beyond the Reach of God".

# Exercises

1/ It will take me about a day, a packet of cigars and a machine full of coffee to write this program and start it running. That is what I am doing now. When I start it running, will I have done a bad thing? If someone were to stop me before the program started running, would that make any difference to anything important?

2/ Can anything except what is computed by this program be said to exist in any sense? Continua, and sets of all sets, and so on, are very problematic. And if the human mind is itself a computation , contained in a universe which itself is a computation, how can we think of or interact with any non-computable thing?

3/ Does the ultimate Truth Table, which the finite tables TT(n) approach as the process continues, exist? What does that question mean? The values of many of its cells are determined. Many of them are not computable. The ratio is unclear.

4/ We can perform the initial stages of this computation with a finite computer with finite memory. At no point does the amount of memory required become infinite. If the computational power of the universe is infinite, then it can contain not only itself but every other thing. If the computation power of the universe is finite, where does that number come from?

5/ The program is very short. Any randomly chosen computation has a good chance of being it. It would probably be very hard to construct an interesting universe which did not contain every possible universe and person.

6/ Does it make any sense to talk about 'not being part of this computation'?