# Boolean Hexagonal Automata

## The Game Rule

A cell is 'on' in generation i+1 if in generation i if it is 'on' in generation i or has exactly 1 neighbor.

## Hexagonal Lattice -> Rectangular Lattice with "holes"

The automaton operates on a hexagonal lattice. Alternating rows produce left- and right-configurations:

0     1     2     3    4
5     6     7     8    9
10    11    12    13   14
15    16    17    18   19
0     1     2     3    4
5     6     7     8    9
10    11    12    13   14
15    16    17    18   19

So e.g. the neighbors of cell 12 are cells 6 7 11 13 16 and 17, and those of cell 7 are cells 2 3 6 8 12 and 13. Translated to a rectangular grid:

0     1     2     3    4
5     6     7     8    9
10    11    12    13   14
15    16    17    18   19
0     1     2     3    4
5     6     7     8    9
10    11    12    13   14
15    16    17    18   19

We can see that neighborhoods centered on even-numbered rows exclude the cells at the upper- and lower-right corners of the 3 x 3 rectangle on which they are centered, and those on odd-numbered rows exclude the cells at the upper- and lower-left.

In the Hex automaton, we compute the next generation with 'next':

The next generation of x is x or 1 = the sum of the alternating adjacencies of x.

The adjacencies - or neighbors - are computed by performing nine transformations on the current state of the universe:

l:1!		rotate up
r:-1!		rotate down
r'		rotate right
l'		rotate left
l'l@		rotate up, then left
l'r@		rotate down, then left
r'l@		rotate up, then right
r'r@		rotate down, then right

The resulting 9 x n x m aligns each cell with its nine neighbors. We can see in the example below which cells must be deleted to form the seven neighbors of a cell on even- and odd-numbered rows.

Hexagonal neighbors of a cell on an even-numbered row:

0  1  2  3  4
5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
19 15 16 17 18
4  0  1  2  3
9  5  6  7  8
14 10 11 12 13

9  5  6  7  8
14 10 11 12 13
19 15 16 17 18
4  0  1  2  3

16 17 18 19 15
1  2  3  4  0
6  7  8  9  5
11 12 13 14 10

6  7  8  9  5
11 12 13 14 10
16 17 18 19 15
1  2  3  4  0

1  2  3  4  0
6  7  8  9  5
11 12 13 14 10
16 17 18 19 15

4  0  1  2  3
9  5  6  7  8
14 10 11 12 13
19 15 16 17 18

15 16 17 18 19
0  1  2  3  4
5  6  7  8  9
10 11 12 13 14

5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
0  1  2  3  4

Hexagonal neighbors of a cell on an odd-numbered row:

0  1  2  3  4
5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
19 15 16 17 18
4  0  1  2  3
9  5  6  7  8
14 10 11 12 13

9  5  6  7  8
14 10 11 12 13
19 15 16 17 18
4  0  1  2  3

16 17 18 19 15
1  2  3  4  0
6  7  8  9  5
11 12 13 14 10

6  7  8  9  5
11 12 13 14 10
16 17 18 19 15
1  2  3  4  0

1  2  3  4  0
6  7  8  9  5
11 12 13 14 10
16 17 18 19 15

4  0  1  2  3
9  5  6  7  8
14 10 11 12 13
19 15 16 17 18

15 16 17 18 19
0  1  2  3  4
5  6  7  8  9
10 11 12 13 14

5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
0  1  2  3  4

Thus, for even-numbered cells we must exclude neighbors on the left- and right-rotation arrays, and for odd-numbered cells we must exclude neighbors on the up- and down-rotation arrays.

The 'alt' function zeroes out the appropriate rows of the first four arrays:

alt:{@[x;!4;*;(::;::;~:;~:)@\:(!(^x)1)!2]}

This has the effect of excluding cells from the subsequent summation in 'next'.

## Acknowledgement

This work was inspired by the J implementation of Coxe and Reiter in Vector Vol. 19 No. 3.

## Implementation

The code is here.

## GUI

(see The Game of Life for details.)