Outline

• Techniques for Proving Uncomputability
• Recursive Enumerability
• Quiz
• Polynomial Time

Techniques for Proving Uncomputability

1. Diagonalization: Given a string `\alpha` let `L_{\alpha}` be some language determined by it. For example, if we view `alpha` as encoding a TM, we could let `L_{\alpha}` be the language decided by `M_{\alpha}`. Let `P_n` be a sequence of sets of ordered pairs of strings with the properties:
   (a) `\forall \langle alpha, x \rangle \exists N \forall n \geq N \langle alpha, x \rangle in P_n iff \langle alpha, x \rangle in P_N`.
   (b) `\forall \alpha \exists N \exists x \forall n > N x \in L_{\alpha} iff x !in P_n`.
   Property (a) ensures `P := lim_{n-> infty}P_n` is well-defined. Property (b) shows that there is no `\alpha` such that `P = L_{alpha}`.
   Diagonalization was used in the proof that UC was not computable, but we didn't frame it exactly like the above. To we see could have though, define `UC_0 = O/`. For `n> 0`, define `UC_n = UC_{n-1}` if `n` viewed as a boolean string does not code an ordered pair `\langle alpha, alpha \rangle`. Otherwise, if `n = \langle \alpha, \alpha \rangle` for some `alpha` then if `M_{\alpha}(\alpha) != 1` define `UC_n = UC_{n-1} \cup \{\langle \alpha, \alpha \rangle\}` otherwise define `UC_n = UC_{n-1}`. One can verify `UC_n` satisfy (a) and (b) and that `UC` from before equals `lim_{n-> infty} UC_n`.
2. Closure Properties: As an example of this technique, first denote, given a language `L`, `bar{L}` for its complement. Notice by changing the final output of a Turing Machine from 0 to 1 and vice-versa, one can show that, if a language is computable, then its complement is computable. Therefore, we know `\bar{UC}` is not computable, because, if it were, its complement `UC` would be as well.
3. Reduction: Here the idea is that if we know problem `P` is not computable, and if we have a problem `P'` together with a computable function `f` such that `x in P` iff `f(x) in P'`, then we know `P'` is not computable. This is because if `P'` were computable, then we could compute `P` by running `f` followed by the procedure for `P'`.

Recursive Functions

• There are a number of computability terms which are used interchangeably. The reason is that these terms come from different ways of characterizing the computable functions.
• Recall a computable function `f:{0,1}^star -> {0,1}^star` is a function computable by some TM.
• If a computable function has output in `{0,1}` we say it is decidable because it solves some decision problem. The set/language corresponding to this function consists of those strings, `x`, such `f(x)=1`. If a `{0,1}` function is not computable its corresponding set is called undecidable.
• By mapping the empty string `eps` to 0, and for any other string prepending a 1 in front of it and subtracting 1in binary we can identify the boolean strings with the binary representation of the natural numbers 0, 1, 2, etc.
• So we can view functions computed by TMs as mappings from `NN -> NN`.
• The primitive recursive functions are the smallest class of functions operating on tuples of natural numbers to natural numbers:
  1. containing the initial functions
     Zero(x) := 0
     S(x) := x+1
     `I_i^n(x_1, ..., x_n) := x_i` (`1 leq i \leq n`) (projects `i`th element from a tuple)
     
  2. closed under composition. I.e., `f(g_1(\vec{x}),..., g_n(\vec{x}))` for `f`, `g_i` already shown to be primitive recursive.
  3. and closed under primitive recursion: If `g(\vec{x})` and `h(\vec{x}, y, z)` are defined, then `f` is defined by primitive recursion from them by the equations:
     `f(\vec{x}, 0) = g(\vec{x})`
     `f(\vec{x}, n + 1) = h(\vec{x}, n, f(vec{x}, n))`
• You can think of primitive recursion as a closure property a little like for loops.
• Another operator, the `mu`-operator, allows us to do things like while loops. Given a function `R(\vec{x}, y)`, let `\mu y R(\vec{x}, y)` be the function that returns the least `y` such that `R` on input `(x,y)` outputs `1` and is undefined if no such `y` exists.
• The partial recursive functions are the closure of the primitive recursive functions under `\mu`-operation. A partial recursive function which has a defined output on all inputs is called total recursive or just recursive.

Computability and Recursiveness are the Same

Remarks

1. We call the equivalent classes of (b), the recursively enumerable (r.e.) or computably enumerable (c.e) sets. (b).5 is a cool result proven by Matiyasevich (1970) solving the Hilbert's 10th problem.
2. I will tend to use the words set and language interchangeably. If `P` is a set of tuples of strings, I will often use the predicate notation, `P(x_1, ..., x_n)`, to mean `(x_1, ..., x_n) \in P`.
3. The set of strings/language accepted by a TM, M, is defined to be those string on which `M` halt with 1 on the output tape.
4. Given a language `L` let the complement of the language, `bar{L}` consist of those string not in `L`. We've already argued that the `bar{UC}` is not recursive. It is also not r.e. So the r.e. are not all of the undecidable sets. `bar{UC}` is in a class called co-r.e. One can show any co-r.e. set can be written as `forall y in {0,1}^{\star} R(\vec{x}, y)` where `R(x, y)` is decidable.
5. Define `\Sigma_0 = \Pi_0 = R` where `R` is the class of decidable/recursive languages. Define `Sigma_n` to contain `Sigma_{n-1} cup Pi_{n-1}` and if `R(x,y)` is `Sigma_n` so is `exists y in {0,1}^{\star} R(\vec{x}, y)`. Define `\Pi_n` to contain `Sigma_{n-1} cup Pi_{n-1}` and if `R(\vec{x},y)` is `Pi_n` so is `forall y in {0,1}^{\star} R(x, y)`. It is known that `\Sigma_n \ne \Pi_n` and `\Sigma_{n+1}` strictly contains `\Sigma_n` and `\Pi_{n+1}` strictly contains `\Pi_n`. The union of all the `\Sigma_n` and `\Pi_n` form the arithmetic hierarchy.

Quiz

Which of the following statements is true?

1. We showed that by increasing the size of the tape alphabet, if something is computable by a TM in time `T(n)` it is also computable in time `(T(n))^{1/2}`
2. There are boolean functions computable using the alphabet `{0, 1, 2, square, Delta }` not computable using the alphabet `{0, 1, square, Delta }`.
3. We used diagonalization to show the language UC is not computable.

Proof of Theorem Part (a)

We briefly indicate how (a) can be shown, but don't give all the details.

• First we show the computable functions contain the total recursive functions...
  • We can show the computable functions of the natural numbers contain each of the initial primitive recursive functions. For example, we can show there is a TM which on any input erases it and outputs 0, we can show there is a TM which when given a number adds 1 to it, given an encoding of an ordered tuple, we can build a TM which write out one particular coordinate of it.
  • Given TMs for `g_1`, ..., `g_m` and `f`, we can built a TM which firsts runs each `g_i` on the appropriate coordinate of the input, takes their outputs and runs `f` on the result.
  • To simulate primitive recursive up to some value `y`, we have an auxiliary tape which we copy `y` to and a counter tape in which we count up to `y`. If `y` is 0 then we run a TM for `g` and use its output, otherwise, for `0 < i leq y`, we use the value obtained at stage `i-1`, `y_{i-1}`, and run the TM for `h` on the encoding of `(\vec{x}, i-1, y_{i-1})`.
  • To handle the `mu`-operation, we first run `R(\vec{x}, 0)` and see if it halts with a value `>0`, if not we try `R(\vec{x}, 1)`, etc until we find such a value.
• For the reverse direction, we first build up a repertoire of recursive functions.
  • For example, we can show `f_+(x,y) = x+y` is primitive recursive via the definition:
    `g(x) := x`
    `h(x, n, z) := I_3^3(x, n, z) + 1`
    `f_+ (x,0) := g(x) = x`
    `f_+ (x, n+1) := h(x,n, f_+(x, n)) = I_3^3(x,n, f_+(x, n)) + 1 = f_+(x, n) +1`
    In a similar fashion, can define the limited subtraction function, `max(x-y, 0)`, multiplication, `2^i`, division rounded down.
  • Using these function we can define functions which project out blocks of bits from a number. For example, the function which chops off the low order `i` bits of a number `x` can be defined as `lfloor x/2^i rfloor`. And the function which returns only the low order `i` bits of a number can be defined as `max(x - lfloor x/2^i rfloor 2^i, 0)`.
  • Define a configuration of a TM to be an encoding of its current state, together with the contents of its non-blank squares. Building on the block of bit manipulation functions, we can primitively recursively define functions, Star`t_M`(x) which from an input `x` computes a starting configuration of `M` on x, Nex`t_M`(C) which given a configuration `C` of `M` computes the configuration `M` would be in after a single step from `C`, and Com`p_M`(x, n), which computes the configuration after the first `n` steps of a computation of `M` on `x` and outputs some configuration `C`. Using `mu`-operator, we can find the least `n` such that Com`p_M`(x, n) is a halting configuration, finally, using this we can build a function which computes the halting configuration of `M` on input `x` if it exists and use one more function to compute the output given this configuration.

Proof of Theorem Part (b)

Again, we are only sketching the ideas without giving full proofs.

• That (b).2 and (b).3 are equivalent uses the same arguments as in our proof of part (a) of the theorem.
• To see (b).1 and (b).2 are equivalent, suppose `L` is a language reducible to the halting problem via some computable function `f`. This means `x in L` iff `f(x) in HALT`. Consider the Turing Machine `M` that operates as follows: On input `x`, it first computes `f(x)`. Since `f(x)` is supposed to be an input to `HALT`, it is of the form `\langle alpha', x' \rangle` for some encoding of a Turing machine `alpha'` and some string `x'`. `M` now starts running like a universal TM on this input `\langle alpha', x' \rangle`. So `x` will be in the domain of `M` iff `f(x) = \langle alpha', x' \rangle in HALT` iff `x in L`. For the reverse direction, suppose `x in L` iff `M(x)` halts for some TM `M`. Consider the reduction which, on input `x`, outputs the string `langle |~ M ~|, x rangle`. Since the encoding of `M` is a fixed string, this is computable by a TM. Further `x in L` iff `langle |~ M ~|, x rangle in HALT`.
• To see that (b).2 and (b).4 are equivalent, first suppose `x in L` iff `exists y in {0,1}^{\star} R(x, y)` where `R(x, y)` is decidable. Consider the Turing machine `M` which first computes `R(x,0)`. If this halts with a 1 on the tape then M halts, otherwise, it computes `R(x,1)`. If this halts with a 1 on the tape then `M` halts, otherwise, it compute `R(x,2)`, and so on. Hence, `x in L`, iff `x` is in the domain of `M`. For the other direction, suppose `x in L` iff `M` on `x` halts. Consider the machine `M'` which takes input `langle x, n rangle` and then simulates `M` on input `x` for `n` steps. If `M` has halted by this point with value `1`, then `M'` halts with value `1`, otherwise, `M'` halts with value `0`. Here we assume `n` is the encoding of the natural number `n` as a string. Then `x in L` iff `M` on `x` halts iff `exists n in {0,1}^{\star} M'(x, n)`.
• To see that the languages of (b).5 are contained in those of (b).4 just notices that if given the inputs to two polynomials, a TM can compute the values of these two polynomials and check if they are equal. To see the languages of (b).5 contains those of (b).2, suppose `x in L` iff `M` on `x` halts. Define a computation sequence of `M` on `x` to be a tuple `langle C_1, ..., C_m rangle`, encoded as an integer, where `C_1` is a start configuration of `M` on `x`, each `C_{i+1}` follows according to one computation step of `M` from `C_i`, and `C_m` is a halting configuration of `M`. In proving this result Matiyasevich, building on earlier work of Robinson, Davis, and Putnam, uses an existential to guess a potential computation sequence and then shows how to use the polynomial equation to verify it.