Outline

• Machines as Strings
• Universal Turing Machines
• Uncomputability
• Measuring Uncomputability

Machines as Strings

• We will often use the idea that a Turing Machine can be written down as a string.
• To see that this is possible, note we defined a Turing Machine as a triple, `(Gamma, Q, delta)`, so a machine can be written down using the symbols "(", ")", "," together with some way to write down `Gamma`, `Q`, and `delta`. But the content of these three sets can also be expressed using a sequence of ASCII characters.
• Once we have written a TM down in ASCII we can convert to `0`'s and `1`'s by just using the binary representation of ASCII.
• As we will be using the fact that TMs can be coded as strings quite extensively, we want to define our representation scheme so that the following two properties hold:
  • Every string in `{0, 1}^star` represents some TM. To do this, we just say not valid encodings represent the machine that halts immediately on any input and outputs `0`.
  • Every TM is represented by infinitely many strings. This can be ensured by specifying that an encoding of a TM can end with arbitrarily many `1`'s which are ignored.
• We write `lfloor M rfloor` for a binary string that represents the machine `M`. If `alpha` is a string, we write `M_alpha` for the machine it represents.

Universal Turing Machine

• We next observe that general-purpose computers are possible, by exhibiting a universal TM, that can simulate the execution of every other TM `M` given `M`'s descriptions as input.
• Our first proof of this fact will give a UTM that runs quadratically slower than the original machine. We will later show how this can be improved to the following:

Theorem. There exists a TM `U` such that for every `x, alpha in {0, 1}^star`, `U(x, \alpha) = M_alpha(x)`, where `M_alpha` denote the TM represented by `alpha`. Moreover, if `M_alpha` halts within `T` steps then `U(x, \alpha)` halts within `CTlog T` steps, where `C` is a number independent of `|x|` and depending only on `M_alpha`'s alphabet size, number of tapes, and number of states.

Proof of relaxed version. `U` is given an input `x, \alpha`. We can assume `M_alpha` represents a TM with a single work tape, and uses only the alphabet `{Delta, square, 0, 1}` because last day we showed how to transform more general TM variants to this form. This transformation could also be carried out explicitly by `U` on more general encodings. Note also, from our proofs last day, these transformations could introduce a quadratic slowdown in the resulting machine, so we have to be more careful for the non-relaxed version of the result. To do a simulation of `M_alpha`, `U` will use three work tapes in addition to its input and output tapes. `U` uses one if its work tapes, and the input and output tape in exactly the same way as `M_alpha`. It uses its two other work tapes to store a table of `M_alpha`'s transition function on one, and to store `M_alpha`'s state on the other. To simulate one step of `M_alpha`, `U` reads the character from `M_alpha`'s work tape, reads the state from the state tape, and scans the transition table to tape to find what symbol to output to `M_alpha`'s work tape, what new state to write to its state tape, and which direction to move the work tape.

Uncomputability

• It may seem obvious that every boolean function can be computed given sufficient time.
• This turns out not to be the case.
• We call functions which are not computable uncomputable. Boolean function which are uncomputable are called undecidable languages.
• The proof that there exists undecidable languages is based on an important technique called diagonalization.

Theorem. There exists a function `UC: {0, 1}^star -> {0,1}` that is not computable by any TM.

Proof. Define `UC` as: For every `alpha in {0, 1}^star`, if `M_alpha(alpha) = 1` then `UC(alpha) = 0`; otherwise, `UC(alpha) = 1`. Suppose for the sake of contradiction that `UC(alpha)` were computable. Then there would exist a TM `M` such that `M(alpha) = UC(alpha)` for all `alpha in {0, 1}^star`. Then `M(lfloor M rfloor) = UC(lfloor M rfloor)`. But this is impossible as by the definition of `UC`
`UC(lfloor M rfloor) = 1 iff M(lfloor M rfloor) ne 1`.

The Halting Problem

• We next show a more natural uncomputable function. The function `mbox(HALT)` as input `langle alpha, x rangle` and outputs `1` if and only if the TM `M_alpha` represented by `alpha` halts on input `x` within a finite number of steps.
• This would be a useful function to compute as using it we could detect if a program will ever go into an infinite loop on a given input.

Theorem. `mbox(HALT)` is not computable by any TM.

Proof. Suppose `mbox(HALT)` was computable by some TM `M_(mbox(HALT))`. We will use `M_(mbox(HALT))` to make a TM `M_(UC)` for the function `UC` giving a contradiction to out last theorem. The machine `M_(UC)` operates as follows: on input `alpha`, `M_(UC)` computes `M_(mbox(HALT))(alpha, alpha)`. If the result is `0`, then `M_(UC)` outputs `1`; otherwise, `M_(UC)` outputs 0. If `mbox(HALT)` were computable then `M_(mbox(HALT))(alpha, alpha)` would halt in a finite number of steps and `M_(UC)` would be computable, giving a contradiction.

• The proof technique used in the above is called a reduction. We showed the problem of computing `UC` is reducible to computing `mbox(HALT)`.
• This is perhaps one of the most common techniques for showing a problem is uncomputable.

In-Class Exercise

• Consider the function `mbox(ZERO)` which on input `alpha` outputs `1` if and only if the TM `M_{\alpha}` halts on all strings containing `0`.
• Use the reduction technique just illustrated to show this function is uncomputable.
• Once you are done, upload your solution to the Feb 8 Class Thread, and I'll try to look at it and give some feedback in class.