## Friday, December 25, 2009

### The 17x17 challenge: setting up the grid

In the previous post, I talked about the 17x17 challenge, but did not provide any code.  Today, I will describe the code I use to represent a given grid.  Consider the following grid where A and b are used to represent two different colours:
```AbAb
bAbA
bbAA```
```bAAA
```
This grid has two rectangles, one of which is emphasized below
```....
.A.A
....
.A.A
```
Finding such a rectangle in a small grid is fairly easy to do.  A naive, but very inefficient way to do this is to have a function like the following:
```def find_rect_candidates(row_1, row_2):
points_in_common = [0, 0, ...] # one per colour
for i, point in enumerate(row_1):
if row_1[i] == row_2[i]:
points_in_common[row_1[i]] += 1
return points_in_common```
where row_x[i] is set to a given colour, represented by an integer (0, 1, 2, ...). For an NxN grid, the first loop is of order N.  Note that this does not tell us (yet) if we have found a rectangle; we still have to loop over points_in_common and see if any entry is greater than 1.

A better way to do the comparison, which does not grow with N, is mentioned in this post and is based on the following observation:  for a given row, at a given point, a given colour is either present (True or 1) or not (False or 0). Thus, a given colour distribution on a single row can be represented as a string of 0s and 1s ... which can be thought of as the binary representation of an integer.  For example, the row containing the colour "A" in the pattern ".....A..A" can have this pattern represented by the number 9="1001".  Consider another row represented by the number 6="110". These two rows have no points in common (for this colour) and hence do not form a rectangle.  If we do a bitwise "and" for these two rows, i.e. 9&6 we will get zero.  This is achieved by a single operation instead of a series of comparisons.

What happens if two rows have a single point in common (for a given colour) so that no rectangle is present?  For example, consider 9="1001" and 15="1110".  If we do a bitwise "and" we have

answer = 9 & 15 = 8 = "1000"

answer & (answer-1) = 8 & 7 = "1000" & "111" = 0.

If we have two points (1 bit) in common, it is easy to see that the bitwise comparison of answer & (answer-1) will not give zero.

Going back to the function above, we could rewrite it instead as follows:

```def find_rect_candidates(row_1, row_2, colours):
points_in_common = [0, 0, ...] # one per colour
for c in colours:
points_in_common[c] = row_1[c] & row_2[c]
return points_in_common```

where we still have to do the same (N-independent) processing of the return value as with the function above to determine if we do have rectangles.

Now, without further ado, here is the basic code that I use to represent a grid, together with two utility functions.

```def rectangles_for_two_rows(row_1, row_2):
'''returns 0 if two rows (given colour, encoded as a bit string)
do not form a rectangle -
otherwise returns the points in common encoded as a bit string'''
intersect = row_1 & row_2
if not intersect:   # no point in common
return 0
# perhaps there is only one point in common of the form 00010000...
if not(intersect & (intersect-1)):
return 0
else:
return intersect

def count_bits(x):
'''counts the number of bits
see http://stackoverflow.com/questions/407587/python-set-bits-count-popcount
for reference and other alternative'''
return bin(x).count('1')

class AbstractGrid(object):
def __init__(self, nb_colours, max_rows, max_columns):
self.nb_colours = nb_colours
self.colours = list(range(nb_colours))
self.max_rows = max_rows
self.max_columns = max_columns
self.powers_of_two = [2**i for i in range(max_columns)]
self.grid = {}

def initialise(self):
'''initialise a grid according to some strategy'''
raise NotImplemented

def print_grid(self):
'''prints a representation of the grid.
Used for diagnostic only - no need to optimize further.'''
for row in self.grid:
row_rep = []
for column in range(self.max_columns-1, -1, -1):
for colour_ in self.colours:
if self.powers_of_two[column] & self.grid[row][colour_]:
row_rep.append(str(colour_))
print("".join(row_rep))

def identify_intersect_points(self):
'''identifies the dots that contribute to forming rectangles'''
# possibly could cut down the calculation time by only computing
# for colours that have changed...
nb_intersect = [0 for colour in self.colours]
intersect_info = []
for colour in self.colours:
for row in self.grid:
for other_row in range(row+1, self.max_rows):
intersect = rectangles_for_two_rows(
self.grid[row][colour],
self.grid[other_row][colour])
if intersect != 0:
nb_intersect[colour] += count_bits(intersect)
intersect_info.append([colour, row, other_row, intersect])
return nb_intersect, intersect_info```

The actual code I use has a few additional methods introduced for convenience.  If anyone can find a better method to identify intersection points between rows (from which rectangles can be formed), I would be very interested to hear about it.

### The 17x17 challenge

In a recent blog post, William Gasarch issued a challenge: find a 17x17 four-colour grid for which there are no rectangles with 4 corners of the same colour.  If you can do this, Gasarch will give you \$289.  For a more detailed explanation, you can either read Gasarch's post, or this post which contains a slightly friendlier explanation of the problem.

This problem, which is fairly easy to state, is extremely hard to solve as the number of possible grid configurations is 4289 which is a number much too large to solve by random searches or by naive methods.  As can be seen from the comments of the posts mentioned above, many people have devoted a lot of cpu cycles in an attempt to find a solution, but with no success.  Like others, I have tried to write programs to solve it ... but with no luck.  In a future post, I may write about the various strategies I have implemented in Python in an attempt to solve this problem.

Gasarch mentions that it is not known if a solution can be found for a 17x18 four-colour grid or even an 18x18 grid or a 17x19 one.  (Note that because of symmetry, an MxN solution can be rotated to give an NxM solution.)  While the number of configurations is large, the larger the grid is, I believe I have found a proof demonstrating that no solution can be found for a 17x18 grid.  This proof builds on the work of Elizabeth Kupin who has found the largest "colour class" i.e. the number of single-colour points on a 17x17 grid which is rectangle-free.  A generic solution found by Kupin is reproduced below:

Consider a 17x18 grid (17 rows and 18 columns).  Such a grid has 306 points.  Using the pigeonhole principle, one can easily show that, for any colouring, at least one colour must cover 77 points.  (Indeed, the most symmetric colouring would be 77, 77, 76, 76.)  Also, if a 17x18 rectangle-free solution exist, it must contain a 17x17 rectangle-free subset, which we take to be the above solution (other solutions for the 17x17 grid can be derived from this one using interchanges of rows and/or columns).

Let us attempt to add points in an additional column. First, we can try to add points in a row with 4 elements.  Without loss of generality, we can take this row to be the first one (row A).  Once we do this, we can not add any more points to row 3-17 without creating a rectangle.  The only row to which we can add a point is the second (row B) bringing the total number of points to 76 - one short of what we need.

Perhaps we can first remove a point from the 17x17 solution and then add a new column.  There are three cases we must consider: 1) that of a point belonging to a row with 5 points and a column with 5 points; 2) that of a point belonging to a row with 5 points and a column with 4 points; 3) that of a point belonging to a row with 4 points and a column with 5 points.

Case 1) Without loss of generality, let us move the point on row F in the first column to a new additional column, keeping the number of points at 74.  It is easy to show that the only rows to which we can then add an additional point without creating a rectangle are rows A, C, D, E. Once we add such a point (say on row A), we can no longer add a point on any of the remaining rows (C, D, E) without creating a rectangle.

Case 2) Without loss of generality, let us move the left-most point on row Q to a new column.  The only row to which we can then add a point in this new column is row A, bringing the total to 75.  We can't add another point without creating a rectangle.

Case 3) Again, without loss of generality, let us remove the top-left element (A) and move it to a new column added to the above solution.  We can add one more point, bringing the total to 75, to that new column (in row B) without creating a rectangle; any other addition of a point on that new column will result in a rectangle.

This concludes the sketch of the proof.

UPDATE: Instead of adding a column, we can add a row (R) with 3 points located in the 9th, 12th and 17th column, bringing the total to 77 points and keeping the grid rectangle-free.  So the 17x18 case is still open... but I can't see how one could add a row with an extra 4 points to build a "single-colour" rectangle-free 17x19 grid.  (However, I won't venture again to say it is a proof until I have looked at all cases exhaustively.)

Note that construction of solutions for a 17x17 grid such as those found by Kupin, even for a single colours, can possibly be used to restrict the search space for the more general problem and help find a solution.  Unfortunately, no one has been able to do this (yet).