The reference in G&J is to an “unpublished result” (by Garey and Johnson themselves, with Papadimitriou). I think the solution I found is not the one they are referring to.

**The problem: **Square Tiling. This is problem GP13 in the appendix.

**The description: **Given a set C of colors, and a set T of tiles, where each of the 4 sides of the tile are colors from C (listed as a 4-tuple of (top, right, bottom, left) colors), and an integer N. Can we tile an NxN square of tiles using tiles from C? We can use a tile more than once, the tiles can’t be rotated, and adjacent edges need to match colors.

**Example: **Here are some example tiles I drew:

We can tile these into a 3×3 grid like this:

**Reduction: **As I said above, the reference in G&J is to an “unpublished result” by Garey, Johnson, and Papadimitriou. I did manage to find a “generic reduction” using Turing Machines in the Lewis and Papadimitriou Theory book.

The reduction is from the “N_{2}” language in the book, which (I think) is “Can a Turing Machine M halt in t steps or less with its head on the tape in configration uσv, where u and v are strings in Σ*, and σ is the location of the head (and a symbol in the alphabet)?

The idea is that we’ll build a set of tiles whose colors are based on the number of steps the computation has done so far. The colors are actually tuples. So, we have several kinds of tiles:

- For each a in Σ*, and each k from 1 to t, a tile with color (a, k+1) on the top, and (a,k) on the bottom. This simulates a move that stays in the same state and writes the same symbol.
- For each pair a,b in Σ*, and each state p,q in M (p can include the halt state, q can’t), a tile with the color (p,b,k+1) on the top and (q,a,k) on the bottom. This simulates going from state p to state q and replacing an a with a b.
- We can transition from one of the above types of tiles to another using a sideways move. (If the head moves left or right, we move to a tile to the left or right)
- There are special tiles for the start row and for when the machine halts.

We set our N (the size of the tiling grid we’re making) to t+2. What we’ve built is a system that:

- Has to have the tiles corresponding to one of the start states on the bottom row
- Has in row i a tile corresponding to a configuration of the machine after i steps. (A path of tiles from the bottom to row i show the computation needed to get to that state)
- Has at the top row a tile corresponding to a configuration after t+1 steps. If there is a legal tiling, one of those tiles must contain the halt state.

..which they claim is the same as the N_{2} langauge.

The suggested reduction in the appendix is from Hamiltonian Path, and I spent some time thinking about how to make that work, but couldn’t do it. Do you make tiles correspond to vertices? Do you make colors correspond to vertices? How do you account for the fact that you can go in two dimensions? How do you account for the fact that you don’t know the order in which you visit the tiles? I think it might be similar to this way of thinking about configurations.

**Difficulty: **9 because it’s such a non-standard way of doing things. I bet the Hamiltonian Path reduction is a lot easier.