### Solving edge-match puzzles with Arc and backtracking

I recently saw a tricky nine piece puzzle and wondered if I could use Arc to solve it. It turned out to be straightforward to solve using standard backtracking methods. This article describes how to solve the puzzle using the Arc language. The puzzle consists of nine square titles. The tiles must be placed so the pictures match up where two tiles meet. As the picture says, "Easy to play, but hard to solve." It turns out that this type of puzzle is called an edge-matching puzzle, and is NP-complete in general. For dozens of examples of these puzzles, see Rob's Puzzle Page.

Backtracking is a standard AI technique to find a solution to a problem step by step. If you reach a point where a solution is impossible, you backtrack a step and try the next possibility. Eventually, you will find all possible solutions. Backtracking is more efficient than brute-force testing of all possible solutions because you abandon unfruitful paths quickly.

To solve the puzzle by backtracking, we put down the first tile in the upper left. We then try a second tile in the upper middle. If it matches, we put it there. Then we try a third tile in the upper right. If it matches, we put it there. The process continues until a tile doesn't match, and then the algorithm backtracks. For instance, if the third tile doesn't match, we try a different third tile and continue. Eventually, after trying all possible third tiles, we backtrack and try a different second tile. And after trying all possible second tiles, we'll backtrack and try a new first tile. Thus, the algorithm will reach all possible solutions, but avoids investigating arrangements that can't possibly work.

### The implementation

I represent each tile with four numbers indicating the pictures on each side. I give a praying mantis the number 1, a beetle 2, a dragonfly 3, and an ant 4. For the tail of the insect, I give it a negative value. Each tile is then a list of (top left right bottom). For instance, the upper-left tile is (2 1 -3 3). With this representation, tiles match if the value on one edge is the negative of the value on the other edge. I can then implement the list of tiles:
```(with (mantis 1 beetle 2 dragonfly 3 ant 4)
(= tiles (list
(list beetle mantis (- dragonfly) dragonfly)
(list (- beetle) dragonfly mantis (- ant))
(list ant (- mantis) beetle (- beetle))
(list (- dragonfly) (- ant) ant mantis)
(list ant (- beetle) (- dragonfly) mantis)
(list beetle (- mantis) (- ant) dragonfly)
(list (- ant) (- dragonfly) beetle (- mantis))
(list (- beetle) ant mantis (- dragonfly))
(list mantis beetle (- dragonfly) ant))))
```
Next, I create some helper functions to access the edges of a tile, convert the integer to a string, and to prettyprint the tiles.
```;; Return top/left/right/bottom entries of a tile
(def top (l) (l 0))
(def left (l) (l 1))
(def right (l) (l 2))
(def bottom (l) (l 3))

;; Convert an integer tile value to a displayable value
(def label (val)
((list "-ant" "-dgn" "-btl" "-man" "" " man" " btl" " dgn" " ant")
(+ val 4)))

;; Print the tiles nicely
(def prettyprint (tiles (o w 3) (o h 3))
(for y 0 (- h 1)
(for part 0 4
(for x 0 (- w 1)
(withs (n (+ x (* y w)) tile (tiles n))
(if
(is part 0)
(pr " ------------- ")
(is part 1)
(pr "|    " (label (top tile)) "     |")
(is part 2)
(pr "|" (label (left tile)) "    " (label (right tile)) " |")
(is part 3)
(pr "|    " (label (bottom tile)) "     |")
(is part 4)
(pr " ------------- "))))
(prn))))
```
The prettyprint function uses optional arguments for width and height: `(o w 3)`. This sets the width and height to 3 by default but allows it to be modified if desired. The part loop prints each tile row is printed as five lines. Now we can print out the starting tile set and verify that it matches the picture. I'll admit it's not extremely pretty, but it gets the job done:
```arc> (prettyprint tiles)
-------------  -------------  -------------
|     btl     ||    -btl     ||     ant     |
| man    -dgn || dgn     man ||-man     btl |
|     dgn     ||    -ant     ||    -btl     |
-------------  -------------  -------------
-------------  -------------  -------------
|    -dgn     ||     ant     ||     btl     |
|-ant     ant ||-btl    -dgn ||-man    -ant |
|     man     ||     man     ||     dgn     |
-------------  -------------  -------------
-------------  -------------  -------------
|    -ant     ||    -btl     ||     man     |
|-dgn     btl || ant     man || btl    -dgn |
|    -man     ||    -dgn     ||     ant     |
-------------  -------------  -------------
```

Next is the meat of the solver. The first function is `matches`, which takes a grid of already-positioned tiles and a new tile, and tests if a particular edge of the new tile matches the existing tiles. (The grid is represented simply as a list of the tiles that have been put down so far.) This function is where all the annoying special cases get handled. First, the new tile may be along an edge, so there is nothing to match against. Second, the grid may not be filled in far enough for there to be anything to match against. Finally, if there is a grid tile to match against, and the value there is the negative of the new tile's value, then it matches. One interesting aspect of this function is that functions are passed in to it to select which edges (top/bottom/left/right) to match.

```;; Test if one edge of a tile will fit into a grid of placed tiles successfully
;;  grid is the grid of placed tiles as a list of tiles e.g. ((1 3 4 2) nil (-1 2 -1 1) ...)
;;  gridedge is the edge of the grid cell to match (top/bottom/left/right)
;;  gridx is the x coordinate of the grid tile
;;  gridy is the y coordinate of the grid tile
;;  newedge is the edge of the new tile to match (top/bottom/left/right)
;;  newtile is the new tile e.g. (1 2 -1 -3)
;;  w is the width of the grid
;;  h is the height of the grid
(def matches (grid gridedge gridx gridy newedge newtile w h)
(let n (+ gridx (* gridy w))
(or
(< gridx 0) ; nothing to left of tile to match, so matches by default
(< gridy 0) ; tile is at top of grid, so matches
(>= gridx w) ; tile is at right of grid, so matches
(>= gridy h) ; tile is at bottom of grid, so matches
(>= n (len grid)) ; beyond grid of tiles, so matches
(no (grid n)) ; no tile placed in the grid at that position
; Finally, compare the two edges which should be opposite values
(is (- (gridedge (grid n))) (newedge newtile)))))
```
With that method implemented, it's easy to test if a new tile will fit into the grid. We simply test that all four edges match against the existing grid. We don't need to worry about the edges of the puzzle, because the previous method handles them:
```;; Test if a tile will fit into a grid of placed tiles successfully
;;   grid is the grid of tiles
;;   newtile is the tile to place into the grid
;;   (x, y) is the position to place the tile
(def is_okay (grid newtile x y w h)
(and
(matches grid right (- x 1) y left newtile w h)
(matches grid left (+ x 1) y right newtile w h)
(matches grid top x (+ y 1) bottom newtile w h)
(matches grid bottom x (- y 1) top newtile w h)))
```
Now we can implement the actual solver. The functions `solve1` and `try` recursively call each other. `solve1` calls `try` with each candidate tile in each possible orientation. If the tile fits, `try` updates the grid of placed tiles and calls `solve1` to continue solving. Otherwise, the algorithm backtracks and `solve1` tries the next possible tile. My main problem was accumulating all the solutions properly; on my first try, the solutions were wrapped in 9 layers of parentheses! One other thing to note is the conversion from a linear (0-8) position to an x/y grid position.

A couple refactorings are left as an exercise to the reader. The code to try all four rotations of the tile is a bit repetitive and could probably be cleaned up. More interesting would be to turn the backtracking solver into a general solver, with the puzzle just one instance of a problem.

```;; grid is a list of tiles already placed
;; candidates is a list of tiles yet to be placed
;; nextpos is the next position to place a tile (0 to 8)
;; w and h are the dimensions of the puzzle
(def solve1 (grid candidates nextpos w h)
(if
(no candidates)
(list grid) ; Success!
(mappend idfn (accum addfn ; Collect results and flatten
(each candidate candidates
(addfn (try grid candidate (rem candidate candidates) nextpos w h))
(addfn (try grid (rotate candidate) (rem candidate candidates) nextpos w h))
(addfn (try grid (rotate (rotate candidate)) (rem candidate candidates) nextpos w h))
(addfn (try grid (rotate (rotate (rotate candidate))) (rem candidate candidates) nextpos w h)))))))

; Helper to append elt to list
(def append (lst elt) (join lst (list elt)))

;; Try adding a candidate tile to the grid, and recurse if successful.
;; grid is a list of tiles already placed
;; candidate is the tile we are trying
;; candidates is a list of tiles yet to be placed (excluding candidate)
;; nextpos is the next position to place a tile (0 to 8)
;; w and h are the dimensions of the puzzle
(def try (grid candidate candidates nextpos w h)
(if (is_okay grid candidate (mod nextpos w) (trunc (/ nextpos w)) w h)
(solve1 (append grid candidate) candidates (+ nextpos 1) w h)))
```

The final step is a wrapper function to initialize the grid:

```(def solve (tiles (o w 3) (o h 3))
(solve1 nil tiles 0 w h))
```

With all these pieces, we can finally solve the problem, and obtain four solutions (just rotations of one solution):

```arc> (solve tiles)
(((1 -2 -4 3) (2 4 1 -3) (4 -1 2 -2) (-3 1 4 -2) (3 -4 -1 2) (2 1 -3 3) (2 -4 -1 -3) (-2 1 4 -3) (-3 -4 4 1))
((2 4 -2 -1) (-3 2 3 1) (4 -3 1 -4) (1 2 -3 4) (-1 3 2 -4) (4 -2 -3 1) (-4 1 3 -2) (4 -3 -2 1) (-1 2 -3 -4))
((1 4 -4 -3) (-3 4 1 -2) (-3 -1 -4 2) (3 -3 1 2) (2 -1 -4 3) (-2 4 1 -3) (-2 2 -1 4) (-3 1 4 2) (3 -4 -2 1))
((-4 -3 2 -1) (1 -2 -3 4) (-2 3 1 -4) (1 -3 -2 4) (-4 2 3 -1) (4 -3 2 1) (-4 1 -3 4) (1 3 2 -3) (-1 -2 4 2)))
arc> (prettyprint (that 0))
-------------  -------------  -------------
|     man     ||     btl     ||     ant     |
|-btl    -ant || ant     man ||-man     btl |
|     dgn     ||    -dgn     ||    -btl     |
-------------  -------------  -------------
-------------  -------------  -------------
|    -dgn     ||     dgn     ||     btl     |
| man     ant ||-ant    -man || man    -dgn |
|    -btl     ||     btl     ||     dgn     |
-------------  -------------  -------------
-------------  -------------  -------------
|     btl     ||    -btl     ||    -dgn     |
|-ant    -man || man     ant ||-ant     ant |
|    -dgn     ||    -dgn     ||     man     |
-------------  -------------  -------------
```
I've used gimp on the original image to display the solution. I've labeled the original tiles A-I so you can see how the solution relates to the original image. Using Arc to display a solution as an image is left as an exercise to the reader :-) But seriously, this is where using a language with extensive libraries would be beneficial, such as Python's PIL imaging library. ### Theoretical analysis

I'll take a quick look at the theory of the puzzle. The tiles can be placed in 9! (9 factorial) different locations, and each tile can be oriented 4 ways, for a total of 9! * 4^9 possible arrangements of the tiles, which is about 95 billion combinations. Clearly this puzzle is hard to solve by randomly trying tiles.
```arc> (* (apply * (range 1 9)) (expt 4 9))
95126814720
```

We can do a back of the envelope calculation to see how many solutions we can expect. If you put the tiles down randomly, there are 12 edge constraints that must be satisfied. Since only one of the 8 possibilities matches, the chance of all the edges matching randomly is 1 in 8^12 or 68719476736. Dividing this into the 95 billion possible arrangements yields 1.38 solutions for an arbitrary random puzzle. (If this number were very large, then it would be hard to create a puzzle with only one solution.)

We can test this calculation experimentally by seeing how many solutions there are are for a random puzzle. First we make a function to create a random puzzle, consisting of 9 tiles, each with 4 random values. Then we solve 100 of these:

```arc> (def randtiles ()
(n-of 9 (n-of 4 (rand-elt '(1 2 3 4 -1 -2 -3 -4)))))
arc> (n-of 100 (len (solve (randtiles))))
(0 0 0 8 0 0 0 8 0 0 0 0 0 0 0 0 0 0 0 4 0 0 0 0 0 0 0 0 0 0 8 0 0 4 0
0 0 4 8 0 8 0 0 0 0 0 0 0 32 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 16 0
0 0 32 8 0 0 0 0 0 0 0 0 12 0 0 0 0 0 0 0 0 0 0 0 8 0 0 4 0 0 32)
arc> (apply + that)
196
```
Out of 100 random puzzles, there are 196 solutions, which is close to the 1.38 solutions per puzzle estimate above. (`that` is an obscure Arc variable that refers to the previous result.) Note that only 16% of the puzzles have solutions, though. Part of the explanation is that solutions always come in groups of 4, since the entire puzzle can be rotated 90 degrees into four different orientations. Solving 100 puzzles took 146 seconds, by the way.

Another interesting experiment is to add a counter to `try` to see how many tile combinations the solver actually tries. The result is 66384, which is much smaller than the 95 billion potential possibilities. This suggests that the puzzle is solvable manually by trial-and-error with backtracking; at a second per tile, it would probably take you 4.6 hours to get the first solution.

### Conclusions

Solving the puzzle with Arc was easier than I expected, and I ran into only minor problems along the way. The code is available as puzzle.arc.

### 64-bit RC6 codes, Arduino, and Xbox remotes I've extended my Arduino IRremote library to support RC6 codes up to 64 bits long. Now your Arduino can control your Xbox by acting as an IR remote control. (The previous version of my library only supported 32 bit codes, so it didn't work with the 36-bit Xbox codes.) Details of the IRremote library are here.

Note: I don't actually have an Xbox to test this code with, so please let me know if the code works for you.

This code is in my "experimental" branch since I'd like to get some testing before releasing it to the world. To use it:
• Download the IRremote library zip file from GitHub from the Arduino-IRremote experimental branch.
• Move/rename the shirriff-Arduino-IRremote-nnnn directory to arduino-000nn/libraries/IRremote.

#### Sending an Xbox code

The following program simply turns the Xbox on, waits 10 seconds, turns it off, and repeats.
```#include <IRremote.h>
IRsend irsend;
unsigned long long OnOff = 0xc800f740cLL;
int toggle = 0;

void sendOnOff() {
if (toggle == 0) {
irsend.sendRC6(OnOff, 36);
} else {
irsend.sendRC6(OnOff ^ 0x8000, 36);
}
toggle = 1 - toggle;
}

void setup() {}

void loop() {
delay(10000);  // Wait 10 seconds
sendOnOff();  // Send power signal
}
```
The first important thing to note is that the On/Off code is "unsigned long long", and the associated constant ends in "LL" to indicate that it is a long long. Because a regular long is only 32 bits, a 64-bit long long must be used to hold the 64 bit code. If you try using a regular long, you'll lose the top 4 bits ("C") from the code.

The second thing to notice is the toggle bit (which is explained in more detail below). Every time you send a RC5 or RC6 code, you must flip the toggle bit. Otherwise the receiver will ignore the code. If you want to send the code multiple times for reliability, don't flip the toggle bit until you're done.

#### Receiving an Xbox code

The following code will print a message on the serial console if it receives an Xbox power code. It will also dump the received value.
```#include <IRremote.h>

int RECV_PIN = 11;
IRrecv irrecv(RECV_PIN);
decode_results results;

void setup()
{
Serial.begin(9600);
}

void loop() {
if (irrecv.decode(&results)) {
if ((results.value & ~0x8000LL) == 0xc800f740cLL) {
Serial.println("Got an OnOff code");
}
Serial.println(results.value >> 32, HEX);
Serial.println(results.value, HEX);
irrecv.resume(); // Receive the next value
}
}
```
Two things to note in the above code. First, the received value is anded with ~0x8000LL; this clears out the toggle bit. Second, Serial.println is called twice, first to print the top 32 bits, and second to print the bottom 32 bits.

The output when sent power codes multiple times is:

```Got an OnOff code
C
800FF40C
Got an OnOff code
C
800F740C
Got an OnOff code
C
...
```
Note that the received value is split between the two Serial.println calls. Also note that the output oscillates between ...F740C and ...FF40C as the sender flips the toggle bit. This is why the toggle bit must be cleared when looking for a particular value.

The IRremote/IRrecvDump example code has also been extended to display values up to 64 bits, and can be used for testing.

#### A quick description of RC6 codes

RC6 codes are somewhat more complicated than the usual IR code. They come in 20 or 36 bit varieties (that I know of). The code consists of a leader pulse, a start bit, and then the 20 (or 36) data bits. A 0 bit is sent as a space (off) followed by a mark (on), while a 1 bit is sent as a mark (on) followed by a space (off).

The first complication is the fourth data bit sent (called a trailer bit for some reason), is twice as long as the rest of the bits. The IRremote library handles this transparently.

The second complication is RC5 and RC6 codes use a "toggle bit" to distinguish between a button that is held down and a button that is pressed twice. While a button is held down, a code is sent. When the button is released and pressed a second time, a new code with one bit flipped is sent. On the third press, the original code is sent. When sending with the IRremote library, you must keep track of the toggle bit and flip it each time you send. When receiving with the IRremote library, you will receive one of two different codes, so you must clear out the toggle bit. (I would like the library to handle this transparently, but I haven't figured out a good way to do it.)

For details of the RC6 encoding with diagrams and timings, see SB projects.

#### The LIRC database

The LIRC project collects IR codes for many different remotes. If you want to use RC6 codes from LIRC, there a few things to know. A typical code is the Xbox360 file, excerpted below:
```begin remote
name  Microsoft_Xbox360
bits           16
flags RC6|CONST_LENGTH
pre_data_bits   21
pre_data       0x37FF0

begin codes
OpenClose                0x8BD7
XboxFancyButton          0x0B9B
OnOff                    0x8BF3
...
```
To use these RC6 code with the Arduino takes a bit of work. First, the codes have been split into 21 bits of pre-data, followed by 16 bits of data. So if you want the OnOff code, you need to concatenate the bits together, to get 37 bits: 0x37ff08bf3. The second factor is the Arduino library provides the first start bit automatically, so you only need to use 36 bits. The third issue is the LIRC files inconveniently have 0 and 1 bits swapped, so you'll need to invert the code. The result is the 36-bit code 0xc800f740c that can be used with the IRremote library.

The rc6_mask specifies which bit is the double-wide "trailer" bit, which is the fourth bit sent (both in 20 and 36 bit RC6 codes). The library handles this bit automatically, so you can ignore it.

The toggle_bit_mask is important, as it indicates which position needs to be toggled every other transmission. For example, to transmit OnOff you will send 0xc800f740c the first time, but the next time you will need to transmit 0xc800ff40c.

More details of the LIRC config file format are at WinLIRC.

#### Xbox codes

Based on the LIRC file, the following Xbox codes should work with my library:
 OpenClose 0xc800f7428 XboxFancyButton 0xc800ff464 OnOff 0xc800f740c Stop 0xc800ff419 Pause 0xc800f7418 Rewind 0xc800ff415 FastForward 0xc800f7414 Prev 0xc800ff41b Next 0xc800f741a Play 0xc800ff416 Display 0xc800f744f Title 0xc800ff451 DVD_Menu 0xc800f7424 Back 0xc800ff423 Info 0xc800f740f UpArrow 0xc800ff41e LeftArrow 0xc800f7420 RightArrow 0xc800ff421 DownArrow 0xc800f741f OK 0xc800ff422 Y 0xc800f7426 X 0xc800ff468 A 0xc800f7466 B 0xc800ff425 ChUp 0xc800f7412 ChDown 0xc800ff413 VolDown 0xc800ff411 VolUp 0xc800ff410 Mute 0xc800ff40e Start 0xc800ff40d Play 0xc800f7416 Enter 0xc800ff40b Record 0xc800f7417 Clear 0xc800ff40a 0 0xc800f7400 1 0xc800f7401 2 0xc800ff402 3 0xc800f7403 4 0xc800ff404 5 0xc800f7405 6 0xc800ff406 7 0xc800f7407 8 0xc800ff408 9 0xc800f7409 100 0xc800ff41d Reload 0xc800f741c

#### Key points for debugging

The following are the main things to remember when dealing with 36-bit RC6 codes:
• Any 36-bit hex values must start with "0x" and end with "LL". If you get the error "integer constant is too large for 'long' type", you probably forgot the LL.
• You must use "long long" or "unsigned long long" to hold 36-bit values.
• Serial.print will not properly print 36-bit values; it will only print the lower 32 bits.
• You must flip the toggle bit every other time when you send a RC6 code, or the receiver will ignore your code.
• You will receive two different values for each button depending if the sender has flipped the toggle bit or not.