I have worked on a large rulespace before. It is the R3 Cross rulespace. Here is the code I used to generate all the transitions:

Code: Select all

```
def binary(a):
return 2048*a[0]+1024*a[1]+512*a[2]+256*a[3]+128*a[4]+64*a[5]+32*a[6]+16*a[7]+8*a[8]+4*a[9]+2*a[10]+a[11]
def qt(a):
return [a[3],a[4],a[5],a[11],a[10],a[9],a[2],a[1],a[0],a[6],a[7],a[8]]
def rf(a):
return [a[0],a[1],a[2],a[8],a[7],a[6],a[5],a[4],a[3],a[9],a[10],a[11]]
def func(a):
if a == 0:
return 'B'
if a == 1:
return 'A'
import csv
file = open('transitions', 'w')
nums = []
rows = []
for a in range(0, 2):
for b in range(0, 2):
for c in range(0, 2):
for d in range(0, 2):
for e in range(0, 2):
for f in range(0, 2):
for g in range(0, 2):
for h in range(0, 2):
for i in range(0, 2):
for j in range(0, 2):
for k in range(0, 2):
for l in range(0, 2):
m = [a,b,c,d,e,f,g,h,i,j,k,l]
num = binary(m)
listoflists = [qt(m),qt(qt(m)),qt(qt(qt(m))),rf(m),qt(rf(m)),qt(qt(rf(m))),qt(qt(qt(rf(m))))]
if num not in nums:
alive = a+b+c+d+e+f+g+h+i+j+k+l
rletrans = ('x = 1, y = 1, rule = B/S012345678History\n3.'+func(a)+'3.$3.'+func(b)+'3.$3.'+func(c)+'3.$'+func(d)+func(e)+func(f)+'C'+func(g)+func(h)+func(i)+'$3.'+func(j)+'3.$3.'+func(k)+'3.$3.'+func(l)+'3.!')
row = [alive, rletrans, num]
rows.append(row)
for number in listoflists:
nums.append(binary(number))
with open('transitions.csv', 'w', encoding='UTF8', newline='') as f:
writer = csv.writer(f)
for row in rows:
writer.writerow(row)
```

Because of the twelve for-loops it is not remarkably efficient. However, you can modify this program to create all the 3D INT transitions.

Notation (Generalized

Durnak-Cole, named after the two originators of the idea) is simple: if you need only one letter (the number of transitions with n cells is less than 26), it would be a.b.c.d., etc, if two letters (the number of transitions with n cells is less than 676) it would be aa.ab.ac.ad.ae., etc, etc. The transition's name is the base-26 representation of how lexicographically far the transition is in the set of transitions which have n cells, where n is the number of cells in the transition in question. a = 0, b = 1, and so on until z = 25. Separate transitions are marked by dots.

You can use computerese (letters) for transitions' birth and survival numbers: 0 1 2 3 4 5 6 7 8 9 A B C D E F G H I J K L M N O P. If we have

de Vlieger's Argam then it would be a heck of a lot easier to differentiate transitions and birth/survival cell counts, but it would be much more difficult to type, and it won't show up on browser (unless a proposition is written to put Argam in Unicode).

An example rulestring would be B67aaaa.city/S567Oa.bP. (I am definitely estimating the number of letters needed to make this).

For symmetry, in my program I used the generators of the group D4. However, as you are working with 3D you can use the generators of

O_h (cube symmetries) and concatenate them. You can also derive them as transformations of a list with 26 elements inside.

An alternative is to call the other cells by the 26 English letters: so for example a set of transitions will be a.aegilops.be.city.del, removing the need for B/S numbers.

However, I have other suggestions. I agree that the whole 3D INT thingamajig is impractical.

What we need is (Life-like)

- R1 3D vN (see

cubes.io)

- R1 3D Cuboctahedral (6 face-cells + 12 edge-cells)

- R1 3D Cubic/Bays (proposed name for equivalent of Moore neighbourhood in 3D, named after

Carter Bays, the originator of this idea).

Also, I like the Naszvadian idea of semi-totalistic transitions. We should write that as a triple of numbers, (a,b,c), where a can be no greater than 6, B no greater than 12, and C no greater than 8.

3D wishlist:

- 3D Logic Rule (2D B2ae/S) (two transitions, easy peasy - or not)

- 3D Margolus rules (on second thought this might work better in 4D)