Outline

• Complete Problems
• More Reductions

Complete Problems

• A language `L` is said to Turing-hard (resp. Karp-hard) for a class of languages `C` if every `L'` in `C` Turing-reduces (Karp-reduces) to `L`.
• If, in addition, `L` is in `C`, then `L` is called Turing-complete (resp. Karp-complete) for `C`.
• Basically, the notion of completeness makes more precise the notion of being the hardest kind of problem in a class of languages.

Complete r.e. and NP problems

Theorem.

1. `A_{TM}` is Turing-complete for r.e.
2. `A_{\mbox{clocked TM}} := {\langle M, w, 1^t rangle | \mbox{M is a nondeterministic machine that accepts w in at most t steps} }` is Karp-complete for NP.

Proof. For (1), we already have show that `A_{TM}` is in r.e. (the set of recursively enumerable languages). Suppose `L` in r.e. is recognized by a machine `M`. The function `w -> langle M, w rangle` is Turing computable and `w in L` iff `langle M, w rangle in A_{TM}`. Therefore, `A_{TM}` is Turing-complete. For (2), we first show `A_{\mbox{clocked TM}}` is in NP. An nondeterministic algorithm to recognize this language is as follows: On input `\langle M, w, 1^t rangle`, nondeterministically guess a string `v` of length `t^2`, then verify that `v` codes a sequence of configurations of `M` of length `t`, the first being the start configuration of `M` on `w` and such that the `i+1`st configuration follows from the `i`th. If it does, and `M` accepts `w` then accept, else reject. Now suppose `L` is in NP. Then it can be decided by some nondeterministic machine `M` in time `p(n)` for some polynomial `p`. The function `w -> langle M, w, 1^{p(|w|)} rangle` is polynomial time computable and gives a reduction from `L` to `A_{\mbox{clocked TM}}`.

Emptiness Testing for TMs

• Using reducibility is the most common way to show a language is undecidable or to show it is Karp-hard for NP.
• For this reason we are going to look at some more examples of these kinds of arguments.
• Consider the language:
  `E_{TM}={ langle M rangle | \mbox{M is a TM and }L(M)=emptyset}`.
  Theorem. `E_{TM}` is Turing complete for co-r.e.
  Proof. Notice we can make a Turing machine `M'` that given an encoding of `langle M rangle` cycles over lengths `k= 1, 2, \ldots` and for each `k` checks for each string `w` of length `leq k` whether `M` accepts `w` in `k` step. If it does, it halts accepting; otherwise it continues. This machine recognizes whether `M`'s language is non-empty, thus showing `E_{TM}` is in co-r.e. Now suppose `L` is co-r.e. That means its complement, `bar{L}` is recognized by some TM `M`. So `w` is in `L` iff `M` does not accept `w`. So for any such `M` which is derived from a co-r.e. language and for any input `w`, consider the following machine:
  "`M_1 =` "On input `x`:
  1. If `x ne w`, reject.
  2. If `x = w`, run `M` on input `w` and accept if `M` does."
  This machine is a modification of `M` and it accepts at most one input `w`, and it only accepts this if `M` does. For a fixed machine `M`, the map `w -> \langle M_1 rangle` is computable by a TM. Also, we have `w in L` iff `M` does not accept `w` iff `M_1`'s language is empty iff `langle M_1 rangle` is in `E_{TM}`. So we have shown how to reduce any language in co-r.e. to `E_{TM}`. Therefore, `E_{TM}` is Turing-complete for co-r.e.
  Corollary. `E_{TM}` is undecidable.
  Proof. If `E_{TM}` were decidable. Then every co-r.e. language would be decidable; and hence, also r.e. So the complement of `A_{TM}` would be r.e., which would mean that `A_{TM}` is both r.e. and co-r.e. and hence decidable, giving a contradiction.

A Problem about Regular Languages

Even problems about regular languages can sometimes be hard...

Let `\mbox{REGULAR}_{TM} = { \langle M \rangle | mbox {M is a TM and L(M) is a regular language}}`.

Theorem. `\mbox{REGULAR}_{TM}` is undecidable.

Proof. Suppose `R` decides `\mbox{REGULAR}_{TM}`. Then the following machine decides `A_{TM}`:
"`S =` On input `langle M,w rangle`, where `M` is a TM and `w` is a string:

1. Construct the following machine `M'`:
   `M' = ''` On input `x`:
   If `x` has the form `0^n1^n`, accept.
   If `x` does not have this form, run `M` on input `w` and accept if `M` accepts `w`.
    // So if `M` accepts `w`, then `M'` accepts all strings; otherwise, `M'` only accepts strings of the form `0^n1^n`.' '
2. Run `R` on input `langle M' rangle`.
3. If `R` accepts, accept; otherwise, if `R` rejects, reject."

In the above, the map `langle M,w rangle -> langle M' rangle` can be viewed as a reduction from `\mbox{REGULAR}_{TM}` to `A_{TM}`.

Using reducibility from languages other than `A_{TM}`

• We can use languages other than `A_{TM}` to show a language is undecidable.
• For instance, if `E_{TM}` reduces to some language `A`, then `A` will be undecidable.
• For example, let `EQ_{TM} = { langle M_1, M_2 rangle | M_1\mbox{ and }M_2\mbox{ are TMs and }L(M_1) = L(M_2) }`.
  Theorem. `EQ_{TM}` is undecidable.
  Proof. Suppose `R` decides `EQ_{TM}`, then we can build an `S` solving `E_{TM}` as follows (hence, giving a contradiction):
  "`S = ` On input `langle M rangle`, where `M` is a TM:
  1. Run `R` on `langle M, M_2 rangle`, where `M_2` is the machine that rejects all inputs.
  2. If `R` accepts, accept; otherwise if `R` rejects, reject."
• Since every problem in co-r.e. is Turing reducible to `E_{TM}`, the fact that Turing computable functions are closed under composition and the Turing computable map `langle M rangle -> \langle M, M_2 rangle` shows `EQ_{TM}` is Turing-hard for co-r.e.
• We can show `A_{TM}` is Turing reducible to `EQ_{TM}` using the map `\langle M, w rangle -> langle M_1, M_2 rangle` where `M_1` is the machine from Slide 3. Thus, `EQ_{TM}` is Turing-hard for r.e. Hence, we have:
  Theorem. `EQ_{TM}` is neither r.e. or co-r.e.