I worked this out on paper myself before getting into a discussion with ChatGPT about it, but I relied on it for the write-up below before realizing I needed to correct or at least clarify the direction of axes. I think this works.
This is a rabbit hole, but it should not be too hard to prototype some rules in Python code.
ChatGPT writeup (mostly)
Here is how to get a 3-phase ABC partition (instead of Margolus’ 2-phase) while keeping everything indexable in a simple 3D array.
First divide unit squares along the same NW–SE diagonal into right triangles that can be scaled to equilateral triangles for display. I'm going to assume that i is the row number increasing top to bottom and j is the column number increasing left to right.
The array is:
Code: Select all
A[i][j][t]
i,j = square coordinates
t=0 = bottom triangle
t=1 = top triangle
Define
This produces the repeating pattern (again, i is row top to bottom, j is column left to right)
Code: Select all
0 1 2 0 1 2
1 2 0 1 2 0
2 0 1 2 0 1
So the lattice splits into 3 cosets (A, B, C).
Cycling ABCABC… corresponds to shifting the origin through these cosets.
Disjoint neighborhood lattice
Neighborhood origins form an index-3 sublattice generated by:
determinant = 2*2 - 1*1 = 3
So same-phase disjoint neighbors of (i,j) are:
Any same-phase origin is:
for integers a,b.
The 3 phase offsets
One convenient choice of coset representatives:
So ABC cycling corresponds to shifting the neighborhood origin:
Code: Select all
(i,j) -> (i,j+1) -> (i+1,j+1) -> ...
For a neighborhood with upper-left square corner (i,j),
the 6 triangles in clockwise order are:
Code: Select all
(i, j, 0)
(i, j, 1)
(i, j+1, 0)
(i+1, j+1, 1)
(i+1, j+1, 0)
(i+1, j, 1)
This forms a 6-cycle in the triangular adjacency graph (a “hex” in the triangulated lattice).
Writing CA code for it (my thoughts, not ChatGPT)
Without optimizing it for sparsity, I would begin by enforcing D6 symmetry on the neighborhoods. The simplest way is to implement the rules for symmetry classes and then generate a lookup table, which will have just 64 values. So the only significant code here is to get the cell values and pack them into keys to do lookups. We would do this starting from (0,0), (0,1), (1,1) offsets.
Maybe we're actually better off just grabbing all 8 triangles (or 4 squares with 2 bit packed representation). Then we can do lookups in a still trivially small 256 value table. The problem here is we would need to mask to avoid overwriting values in squares that overlap neighborhoods, so maybe not.
