Outline

• Dominoes and Undecidability
• In-Class Exercise
• Rice's Theorem

Post Correspondence Problem

• We now are going to show that there are problems other than problems for machines which are undecidable.
• To do this we look at dominos... For us, these are pairs of strings `[s|t]`.
• Given a set of dominoes {[`s_1`|`t_1`], `ldots`, [`s_k`|`t_k`] }. we want to know if we can arrange a subset of them (we allow repeats) so that `s_{i_1}, ldots, s_{i_j} = t_{i_1}, ldots, t_{i_j}`. This is called a match and the whole problem is called Post's Correspondence Problem (PCP).
• For example, given the tiles{ [b|ca], [a|ab], [ca|a], [abc|c]}, the following is a match [a|ab][b|ca][ca|a][a|ab][abc|c].
• We can associate a language to this problem as:
  `PCP = { langle P rangle | P mbox{ is an instance of Post's Correspondence Problem with a match}}`

In-Class Exercise

• Find a match using the following tiles: {[100|0], [1|011], [0|01] , [01|010], [10|0], [0|1] }.
• Argue why there is no match for the tiles {[0|00], [11|0], [01|10]}.
• Please post your solution to the May 6 In-Class Exercise Thread.

Undecidability of PCP.

Theorem (Post 1946). PCP is undecidable.

Proof. We show via computation histories that if `PCP` is decidable so is `A_{TM}`, thus giving a contradiction. Given an input `langle M, w rangle` for `A_{TM}` we will construct an instance of `PCP` which will have a match iff `M` accepts `w`. Further, the string of the match which be an accepting computation history of `M` on `w`. To simplify our problem we will consider the following modifications to `A_{TM}` and `PCP`:

1. We assume `M` on input `w` never tries to move left off the tape.
2. If `w = epsilon`, we use the string `square` in place of `w` in the construction.
3. We modify `PCP` to require that a match starts with the first domino.

More Undecidability of PCP

Call the instance of `PCP` that we are building `P`.

1. Put `[#| #q_0 w_1 ldots w_n #]` as the first domino of the `PCP` instance. Playing this domino first will force the string to look like an initial configuration of `M` on `w`.

Next we add dominos to handle the part of the configuration where that the TM might change.

2. For every `a, b` in the tape alphabet, and every states `q, r` of `M` where `q ne q_{mbox{reject}}`, if `delta(q, a) = (r, b, R)`, we put `[qa | br]` into `P`.

3. For every `a, b, c` in the tape alphabet and every states `q, r` in `M` where `q ne q_{mbox{reject}}`, if `delta(q, a) = (r, b, L)`, we put `[cqa | rcb]` into `P`.

Next we add dominos to copy the unchanged parts of configurations and to copy the end of configuration markers

4. For every `a` in the tape alphabet, we put `[a | a]` into `P`.

5. Put `[#|#]` and `[#|square #]` into `P`. (The second is to simulate the case where the size of a configuration grows).

Lastly, we add dominos so that once we get to an accept state, we have a sequence of configurations with an ever smaller number of squares so we can catch up the top row with the bottom row:

6. For every tape symbol `a` we have dominos `[aq_{mbox{accept}} | q_{mbox{accept}} ]` and `[q_{mbox{accept}}a | q_{mbox{accept}} ]` and to complete the match we have `[q_{mbox{accept}}## |#]`

Examples of these Dominos

• Suppose `M` on input `w=0100` starts in state `q_0`.
• Suppose further in this state reading a 0 it goes into state `q_7` writes a `2` and moves right.
• The first five kinds of dominos could be played to get the following partial configuration history:
  

Eliminating the First Domino Condition

• Suppose we have an instance
  `P = {[t_1| b_1],` `[t_2| b_2], ldots, [t_k| b_k]}`
  of `PCP` where we'd like the first domino to be played and we like to make it into a real instance `P^star` of `PCP` without this condition.
• Let `star` and `\$` be new symbols not appearing in the `t_i`'s and `b_i`'s. Given a string `u = u_1 ldots u_n`. Define `star u = star u_1 star u_2 star ldots star u_n`, `star u star = star u_1 star u_2 star ldots star u_n star`, and `u star = u_1 star u_2 star... star u_n star`.
• Then `P^star={[star t_1| star b_1 star], ` `[star t_2|b_2 star], ldots, [star t_k|b_k star], [star\$|\$]}` will have a match in the usual `PCP` iff `P` had a match in the modified `PCP`.

End of the PCP reduction

• So assume we had a decision procedure `D` for `PCP`.
• Consider the machine:
  `S=` "On input `langle M, w rangle`:
  
  1. Construct an instance `langle P^star rangle` of `PCP` following the construction of the last few slides.
  2. Run `D` on `langle P^star rangle`.
  3. If `D` accepts, accept; else if `D` rejects, reject."
  This machine is a decision procedure for `A_{TM}`, which we know cannot exist.
• Therefore, the assumption `D` exists must be false.
• Therefore, `PCP` is undecidable.

PCP Remarks

• The version of PCP where you ask for matches where no more than `k` dominoes are used is NP complete under Karp reductions (Constable, Hunt, Sahni, 1974).
• Post Correspondence Problem (tiling dominoes) has a character similar to other problems such as tiling regions of the plane, etc.
• Hao Wang in the 1960s observing this created what are known as Wang dominoes/tiles, which were square tiles each edge marked with a number. His domino problem was to determine if a set of such dominoes could tile the plane so that tiles sharing an edge have the same number on that edge. Wang in 1961 had shown the problem is decidable iff all instances of the problem either don't tile or are periodic. Wang's student, Berger 1966, showed the problem was unsolvable by exhibiting an aperiodic tiling.
• Raphael Robinson in 1971 reduced the number of kinds of tiles needed in an aperiodic tiling to six, but in so doing made the tiles of an irregular shape.
• Roger Penrose in 1974 introduced the first of his Penrose tilings based on the pentagon which also only needed six tiles. Using a kite shape he was later able to reduce the number of kinds of tiles to two.
• Bounded variants of the tiling problem might seem a lot like the game Tetris. In fact, many problems involving Tetris are known to be NP-hard under Karp reductions (Demaine, et al 2002).
• There has been some work in using Wang Tiles in computer graphics to produce natural looking textures capable of commpletely covering surfaces (Stam 1997, Cohen, et al 2003).
• There has also been some work showing you can make Wang tiles using DNA (Winfree et al 1998, Lukeman 2002).

Rice's Theorem

Rice's theorem (Transactions AMS, 1953) shows that almost any problem one could come up with connected to Turing Machines is undecidable.

Theorem. Let `P` be a language such that there exists TM descriptions `langle M rangle in P` and ` langle M' rangle !in P`. Further assume that whenever we have two machines `M_1` and `M_2` such that `L(M_1) = L(M_2)`, then we have `langle M_1 rangle in P` iff `langle M_2 rangle in P`. Then `P` is undecidable.

Proof. Suppose we had a decider `R` for `P`. We show how to use `R` to build a decider for `A_{TM}`. Let `T_{emptyset}` be a TM which always rejects, so `L(T_{emptyset}) = emptyset`. We may assume `T_{emptyset} !in P`; otherwise, we carry out our argument using `bar P`. Because `P` is not trivial there exists a TM `T` with `T in P`. Using this machine consider the following decider `S` for `A_{TM}`:
`S =` "On input `langle M, w rangle`:

1. Use `M` and `w` to construct the following TM `M_w` :
   `M_w =` "On input `x`:
   1. Simulate `M` on `w`. If it halts and reject, reject. If it accepts, proceed to Stage 2.
   2. Simulate `T` on `x`. If it accepts, accept."
2. Use TM `R` to determine whether `langle M_w rangle in P`. If yes, accept. If no, reject."

Example Use of Rice's Theorem

• Consider the language `L={ langle M rangle| M mbox{is a TM and } 1011 in L(M)}`.
• This language contains some, but not all TM encodings.
• It further has the property that for any `M_1` and `M_2` such that `L(M_1) = L(M_2)`, that we have `langle M_1 rangle in L` iff `langle M_2 rangle in L`.
• Therefore, by Rice's Theorem it is undecidable.

Rice's Theorem Remarks

• Several variants of Rice's Theorem have been considered.
• Perhaps, the first was due to Greibach 1966 (Greibach's Theorem):
  Theorem. Let `C` be a class of languages that is effectively closed under concatenation with regular sets and union, and for which `=\Sigma^star` is undecidable for any sufficiently large fixed `\Sigma`. Let `P` be any nontrivial property, that is true for all regular sets and that is preserved under `/a`, where `a` is a single symbol. (That is, if `L` has the property `P`, so does `L``/ a = { w | wa in L }`.) Then `P` is undecidable for `C`.
• Variants of Rice's Theorem within the class NP can be found in Borchert and Stephan 2000 as well as Hemaspaandra and Thakur 2002.
• Connections between Rice's Theorem, program obfuscation, and the existence of one-way functions in cryptography can be found in Barak, et al., 2001.