3-state range-1 outer-totalistic rulespace

For discussion of other cellular automata.
Post Reply
User avatar
muzik
Posts: 5614
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

3-state range-1 outer-totalistic rulespace

Post by muzik » January 8th, 2020, 11:54 am

This is an obvious, but to my knowledge not thoroughly explored, extension of the familiar 2-state outer-totalistic rules which are frequently investigated.

The notation of a rulestring is as follows (subject to change, if anyone has any better suggestions reply with them):

BA(nn)/BB(nn)/TA(nn)/TB(nn)/SA(nn)/SB(nn)

where:
BA - conditions for a state-1 cell to be born
BB - conditions for a state-2 cell to be born
TA - conditions for a state-1 cell to become a state-2 cell
TB - conditions for a state-2 cell to become a state-1 cell
SA - conditions for a state-1 cell to stay alive
SB - conditions for a state-2 cell to stay alive

Conditions would be a string of two consecutive digits, with the first digit specifying how many neighbouring state-1 cells and the second digit specifying how many state-2 cells. The sum of the consecutive digits cannot exceed 8. A condition cannot be for both transitioning and surviving for a cell. For example, this would be the three-valued replicator rule (with a lot of transitions since that's how XOR rules work):

Code: Select all

x = 1, y = 1, rule = BA020508101316212432354043516270_BB01040712152023263134425053_TA01040712152023263134425053_TB020508101316212432354043516270_SA020508101316212432354043516270_SB01040712152023263134425053
A!
The notation can be extended to von Neumann and hexagonal neighbourhoods like with normal notation. As for the LtL/HROT notation, I'm not sure but it could use the usual HROT comma notation, with each two consecutive numbers being considered one transition.

This would allow for the transcription of a broad range of rules (3^27 if I'm not mistaken), but this is only the tip of the iceberg compared to the isotropic non-totalistic extensions to this rulespace I'm currently working on notating.

ivtb
Posts: 11
Joined: January 21st, 2018, 6:07 pm

Re: 3-state range-1 outer-totalistic rulespace

Post by ivtb » January 14th, 2020, 10:58 am

Nice! I always thought we needed to explore more 3-state rules

I'm gonna try and make a python script that generates ruletrees for this kind of automaton

I think most transitions in are unnecessary since there is no way the outer sum of the cell is greater than 16 (8 state-2 cells)

Edit: Misunderstood your notation. I take back the comment
Last edited by ivtb on January 14th, 2020, 1:21 pm, edited 1 time in total.

User avatar
Moosey
Posts: 4306
Joined: January 27th, 2019, 5:54 pm
Location: here
Contact:

Re: 3-state range-1 outer-totalistic rulespace

Post by Moosey » January 14th, 2020, 11:07 am

Would this be the correct rulestring for deadlyenemies?

Code: Select all

x = 1, y = 1, rule = BA3021_BB0312_TA_TB_SA2030_SB0203
.A.$2.A$3A!
not active here but active on discord

ivtb
Posts: 11
Joined: January 21st, 2018, 6:07 pm

Re: 3-state range-1 outer-totalistic rulespace

Post by ivtb » January 14th, 2020, 1:26 pm

Code: Select all

name = "BA010407101316_BB0205081114_TA0205081114_TB010407101316_SA010407101316_SB0205081114"
n_states = 3
n_neighbors = 8

transitions = sorted(name.split("_"))

BA = transitions[0][2:]
BB = transitions[1][2:]
SA = transitions[2][2:]
SB = transitions[3][2:]
TA = transitions[4][2:]
TB = transitions[5][2:]

def transition_function(a):

    n = a[0]+a[1]+a[2]+a[3]+a[4]+a[5]+a[6]+a[7]

    if a[8] == 0:

        for i in range(len(BA) // 2):
            if (n == int(BA[2*i:2*i + 2])):
                return 1

        for i in range(len(BB) // 2):
            if (n == int(BB[2*i:2*i + 2])):
                return 2

    if a[8] == 1:

        for i in range(len(TA) // 2):
            if (n == int(TA[2*i:2*i + 2])):
                return 2

        for i in range(len(SA) // 2):
            if (n == int(SA[2*i:2*i + 2])):
                return 1

    if a[8] == 2:

        for i in range(len(TB) // 2):
            if (n == int(TB[2*i:2*i + 2])):
                return 1

        for i in range(len(SB) // 2):
            if (n == int(SB[2*i:2*i + 2])):
                return 2
    return 0

I misunderstood the OP and created a notation for a different class of automata, where the sum of all neighbors (with state 2 counting as 2 state 1 cells) determines each transition; each pair of digits represents one possible value for the sum. If less than 10 a leading zero is placed, ex: 09 instead of 9.

Here is a simple replicator rule in this notation

To explore other rules in this category just change "name", copy the code and run make-ruletree.py

ivtb
Posts: 11
Joined: January 21st, 2018, 6:07 pm

Re: 3-state range-1 outer-totalistic rulespace

Post by ivtb » January 14th, 2020, 2:58 pm

Code: Select all

name = "BA02050810131621243235404351627008_BB010407121520232631344250536180_TA010407121520232631344250536180_TB02050810131621243235404351627008_SA02050810131621243235404351627008_SB010407121520232631344250536180"

n_states = 3
n_neighbors = 8

transitions = sorted(name.split("_"))

BA = transitions[0][2:]
BB = transitions[1][2:]
SA = transitions[2][2:]
SB = transitions[3][2:]
TA = transitions[4][2:]
TB = transitions[5][2:]

def transition_function(a):

    ones = 0
    twos = 0

    for i in range(8):
        if a[i] == 1:
            ones += 1
        if a[i] == 2:
            twos += 1

    if a[8] == 0:

        for i in range(len(BA) // 2):
            if (ones == int(BA[2*i]) and twos == int(BA[2*i + 1])):
                return 1

        for i in range(len(BB) // 2):
            if (ones == int(BB[2*i]) and twos == int(BB[2*i + 1])):
                return 2

    if a[8] == 1:

        for i in range(len(TA) // 2):
            if (ones == int(TA[2*i]) and twos == int(TA[2*i + 1])):
                return 2

        for i in range(len(SA) // 2):
            if (ones == int(SA[2*i]) and twos == int(SA[2*i + 1])):
                return 1

    if a[8] == 2:

        for i in range(len(TB) // 2):
            if (ones == int(TB[2*i]) and twos == int(TB[2*i + 1])):
                return 1

        for i in range(len(SB) // 2):
            if (ones == int(SB[2*i]) and twos == int(SB[2*i + 1])):
                return 2
    return 0
Now it's implemented correctly. The rule is your replicator rule with a small correction. Again, just change the rule name and run make-ruletree.py with the code in clipboard

User avatar
muzik
Posts: 5614
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

Re: 3-state range-1 outer-totalistic rulespace

Post by muzik » January 16th, 2020, 2:34 pm

dvgrn, on the discord, wrote:
December 31st, 1969, 8:11 pm
Maybe the "T" transitions should be "TAB" and "TBA"? -- just because the notation as you describe it doesn't extend cleanly to four or more states, but if you specified both the "from" and "to" states after "T" then it would... up to twenty-six states, theoretically, but the rule strings might get too unwieldy well before then.
(But then the syntax might be simplified by using "Z" as the zero state, so there's always a "from" state and a "to" state listed and you wouldn't need B and S for "birth" and "survival".)

User avatar
muzik
Posts: 5614
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

Re: 3-state range-1 outer-totalistic rulespace

Post by muzik » January 19th, 2020, 7:19 pm

Currently in the process of developing a notation for isotropic non-totalistic 3-state rules:

Image

I've also noticed that the BSFKL rulespace also seems to be a subset of the 3-state outer-totalistic rulespace, so software support for the latter might be a higher priority.

Also, something that could be handy: how about a script that converts an applicable ruletable into outer-totalistic 3-state notation? There's quite a few such rules.

ivtb
Posts: 11
Joined: January 21st, 2018, 6:07 pm

Re: 3-state range-1 outer-totalistic rulespace

Post by ivtb » January 20th, 2020, 9:40 pm

muzik wrote:
January 19th, 2020, 7:19 pm
Currently in the process of developing a notation for isotropic non-totalistic 3-state rules:

Image

I've also noticed that the BSFKL rulespace also seems to be a subset of the 3-state outer-totalistic rulespace, so software support for the latter might be a higher priority.

Also, something that could be handy: how about a script that converts an applicable ruletable into outer-totalistic 3-state notation? There's quite a few such rules.
One way to automate this could involve running this pattern for 1 generation in code and adding correspondent transitions into the name string

Code: Select all

x = 81, y = 27, rule = 12/34/3
10.B2.B2.B2.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.11B$4.
A2.B5.A2.B5.A2.B3.B.AB.2B2.B.AB.2B2.B.AB.2B2.B.AB.3B.2BA5B.2BA4B$38.B
2.B2.B.2B.2B.29B$.A2.A2.A2.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.
AB.AB.AB.A2BA2BA2BAB$4.A2.B5.A2.B3.B.AB.2B2.B.AB.2B2.B.AB.2B2.B.AB.3B
.2BA5B.2BA4B$29.B2.B2.B.2B.2B.29B$.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.
2A.2A.2A.2A.2A.2A.2AB2AB2AB2A$4.A2.B3.B.AB.2B2.B.AB.2B2.B.AB.2B2.B.AB
.3B.2BA5B.2BA4B$20.B2.B2.B.2B.2B.29B$.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.
2A.2A.2A.2A.2AB2AB2AB2A$2.A.2A.BA2.A.2A.BA2.A.2A.BA2.A.2A.BAB.AB2A2BA
B.AB2A2BA$11.B2.B2.B.2B.2B.29B$.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.2AB
2AB2AB2A$2.A.2A.BA2.A.2A.BA2.A.2A.BAB.AB2A2BAB.AB2A2BA$2.A2.A2.A.BA.B
A.BA2BA2BA2BA2BA2BA2BA2BA2BA2BA$.2A.2A.2A.2A.2A.2A.2A.2A.2AB2AB2AB2A$
2.A.2A.BA2.A.2A.BAB.AB2A2BAB.AB2A2BA$.2A.2A.2AB2AB2AB2AB2AB2AB2AB2AB
2AB2A$.2A.2A.2A.2A.2A.2AB2AB2AB2A$2.A.2A.BAB.AB2A2BAB.AB2A2BA$27A$.2A
.2A.2AB2AB2AB2A$A.5AB2A.5ABA$18A$9A$A.5ABA$9A!
I tried but something is wrong with my code and I can't make it work using golly.parse and golly.evolve

Up-down dimension is the amount of state-1 cells; Left-right within a group of 3 is center cell state, and between groups of three the amount of state-2 cells

ivtb
Posts: 11
Joined: January 21st, 2018, 6:07 pm

Re: 3-state range-1 outer-totalistic rulespace

Post by ivtb » January 21st, 2020, 11:54 am

muzik wrote:
January 19th, 2020, 7:19 pm
Also, something that could be handy: how about a script that converts an applicable ruletable into outer-totalistic 3-state notation? There's quite a few such rules.
This python script names an outer-totalistic rule. Just set the current rule in golly to the rule you're inspecting, run the script and the rule name will be copied to the clipboard (Using BA/BB/TA/TB/SA/SB notation)

Code: Select all

from golly import *

start = parse('''10.B2.B2.B2.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.2B.11B$4.
A2.B5.A2.B5.A2.B3.B.AB.2B2.B.AB.2B2.B.AB.2B2.B.AB.3B.2BA5B.2BA4B$38.B
2.B2.B.2B.2B.29B$.A2.A2.A2.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.AB.
AB.AB.AB.A2BA2BA2BAB$4.A2.B5.A2.B3.B.AB.2B2.B.AB.2B2.B.AB.2B2.B.AB.3B
.2BA5B.2BA4B$29.B2.B2.B.2B.2B.29B$.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.
2A.2A.2A.2A.2A.2A.2AB2AB2AB2A$4.A2.B3.B.AB.2B2.B.AB.2B2.B.AB.2B2.B.AB
.3B.2BA5B.2BA4B$20.B2.B2.B.2B.2B.29B$.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.
2A.2A.2A.2A.2AB2AB2AB2A$2.A.2A.BA2.A.2A.BA2.A.2A.BA2.A.2A.BAB.AB2A2BA
B.AB2A2BA$11.B2.B2.B.2B.2B.29B$.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.2A.2AB
2AB2AB2A$2.A.2A.BA2.A.2A.BA2.A.2A.BAB.AB2A2BAB.AB2A2BA$2.A2.A2.A.BA.B
A.BA2BA2BA2BA2BA2BA2BA2BA2BA2BA$.2A.2A.2A.2A.2A.2A.2A.2A.2AB2AB2AB2A$
2.A.2A.BA2.A.2A.BAB.AB2A2BAB.AB2A2BA$.2A.2A.2AB2AB2AB2AB2AB2AB2AB2AB
2AB2A$.2A.2A.2A.2A.2A.2AB2AB2AB2A$2.A.2A.BAB.AB2A2BAB.AB2A2BA$27A$.2A
.2A.2AB2AB2AB2A$A.5AB2A.5ABA$18A$9A$A.5ABA$9A!''')

result = evolve(start,1)

def mygetcell(x,y):
    for i in range(len(result) // 3):
        if (x==result[3*i]) and (y==result[3*i + 1]):
            return result[3*i + 2]
    return 0

transitions = []

for s in range(3):
    for i in range(9):
        for j in range(9 - i):
            transitions.append((j,i,s,mygetcell(1+9*i+3*s,1+3*j)))

form = [ [x for x in transitions if x[2] == 0 and x[3] == 1] , [x for x in transitions if x[2] == 0 and x[3] == 2],\
[x for x in transitions if x[2] == 1 and x[3] == 2],[x for x in transitions if x[2] == 2 and x[3] == 1], \
[x for x in transitions if x[2] == 1 and x[3] == 1], [x for x in transitions if x[2] == 2 and x[3] == 2]]


flist = [[],[],[],[],[],[]]
slist = [[],[],[],[],[],[]]
fstr = ["","","","","",""]

for j in range(6):
    for i in form[j]:
        flist[j].append(str(i[0]) + str(i[1]))

for j in range(6):
        slist[j] = sorted(flist[j])
        for i in slist[j]:
            fstr[j] += i

setclipstr("BA" + fstr[0] + "_BB" + fstr[1] + "_TA" + fstr[2] + "_TB" + fstr[3] + "_SA" + fstr[4] + "_SB" + fstr[5])

I ran this script with the generations 12/34/3 rule and it gave me "BA3031323334354041424344_BB_TA000102030405060708303132333435404142434450515253606162707180_TB_SA101112131415161720212223242526_SB"

Using my other script I compiled this into a ruletree:

Code: Select all

name = "BA3031323334354041424344_BB_TA000102030405060708303132333435404142434450515253606162707180_TB_SA101112131415161720212223242526_SB"

n_states = 3
n_neighbors = 8

transitions = sorted(name.split("_"))

BA = transitions[0][2:]
BB = transitions[1][2:]
SA = transitions[2][2:]
SB = transitions[3][2:]
TA = transitions[4][2:]
TB = transitions[5][2:]

def transition_function(a):

    ones = 0
    twos = 0

    for i in range(8):
        if a[i] == 1:
            ones += 1
        if a[i] == 2:
            twos += 1

    if a[8] == 0:

        for i in range(len(BA) // 2):
            if (ones == int(BA[2*i]) and twos == int(BA[2*i + 1])):
                return 1

        for i in range(len(BB) // 2):
            if (ones == int(BB[2*i]) and twos == int(BB[2*i + 1])):
                return 2

    if a[8] == 1:

        for i in range(len(TA) // 2):
            if (ones == int(TA[2*i]) and twos == int(TA[2*i + 1])):
                return 2

        for i in range(len(SA) // 2):
            if (ones == int(SA[2*i]) and twos == int(SA[2*i + 1])):
                return 1

    if a[8] == 2:

        for i in range(len(TB) // 2):
            if (ones == int(TB[2*i]) and twos == int(TB[2*i + 1])):
                return 1

        for i in range(len(SB) // 2):
            if (ones == int(SB[2*i]) and twos == int(SB[2*i + 1])):
                return 2
    return 0
And it works exactly like the original 12/34/3 rule

User avatar
muzik
Posts: 5614
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

Re: 3-state range-1 outer-totalistic rulespace

Post by muzik » January 29th, 2020, 4:18 pm

It should theoretically be easy to generalize this notation up to higher state counts, if we account for all different transitions between cell states. The transitions are as follows:

- 2-state - one alive state - birth of state 1, survival of state 1
- 3-state - two alive states - birth of state 1, birth of state 2, state 2 to state 1, state 1 to state 2, survival of state 1, survival of state 2
- 4-state - three alive states - birth of state 1, birth of state 2, birth of state 3, state 1 to state 2, state 1 to state 3, state 2 to state 3, state 2 to state 1, state 3 to state 1, state 3 to state 2, survival of state 1, survival of state 2, survival of state 3

Beyond 4-state (or arguably 3-state) rules, it does appear to get quite unwieldy with the notation though (especially considering one transition would need four or three digits), so I'd say we're best sticking with outer-totalistic 3-state rules for right now. But to future-proof, it seems best if we heed dave's advice and define more clearly our transition types.

A proposal for the new notation, with only minimal changes:
BA(state 1 birth conditions)/BB(state 2 birth conditions)/TAB(state 1 to 2 transitions)/TBA(state 2 to 1 transitions)/SA(state 1 survival conditions)/SB(state 2 birth conditions)

It may also be worth negating transitions if strings get too long, like with Hensel notation.

I also had a thought about what would happen if, say, a birth condition for state 1 ended up being identical to a birth condition for state 2. How would this end up being handled? I can't think of a good analogy that exists in the 2-state case. Should we simply invalidate such rulestrings, or could another notation which is still human-readable be invented that doesn't have these cases at all?

User avatar
muzik
Posts: 5614
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

Re: 3-state range-1 outer-totalistic rulespace

Post by muzik » February 3rd, 2020, 10:21 am

Here are the 3-state equivalents of the block CA found in 2x2:

Code: Select all

x = 268, y = 2, rule = marg3
2A2.4A2.6A2.8A2.10A2.12A2.14A2.16A2.18A2.20A2.22A2.24A2.26A2.28A2.30A
$2A2.4A2.6A2.8A2.10A2.12A2.14A2.16A2.18A2.20A2.22A2.24A2.26A2.28A2.
30A!
Currently working on the rule so that any arrangement of blocks can work. Sometimes it breaks down with more complex ones but we can see the gist of the effects here.

Comparison to 2 state:

Code: Select all

x = 268, y = 2, rule = B3/S5
2o2b4o2b6o2b8o2b10o2b12o2b14o2b16o2b18o2b20o2b22o2b24o2b26o2b28o2b30o$
2o2b4o2b6o2b8o2b10o2b12o2b14o2b16o2b18o2b20o2b22o2b24o2b26o2b28o2b30o!
Some squares, p4n 4nx4n:

Code: Select all

 x = 40, y = 12, rule = marg3
28.12A$28.12A$10.8A10.12A$10.8A10.12A$4A6.8A10.12A$4A6.8A10.12A$4A6.
8A10.12A$4A6.8A10.12A$10.8A10.12A$10.8A10.12A$28.12A$28.12A!

User avatar
muzik
Posts: 5614
Joined: January 28th, 2016, 2:47 pm
Location: Scotland

Re: 3-state range-1 outer-totalistic rulespace

Post by muzik » June 24th, 2020, 11:52 am

Should we consider this the canonical notation now?

User avatar
praosylen
Posts: 2443
Joined: September 13th, 2014, 5:36 pm
Location: Pembina University, Home of the Gliders
Contact:

Re: 3-state range-1 outer-totalistic rulespace

Post by praosylen » May 12th, 2021, 6:08 pm

I have a new proposal for a compacted 3-state R1OT notation — honestly it's more of an evolved version of some of the things other people have already posted, the main design goal is just to be at least somewhat human-readable and -writable as well as reasonably compact for a lot of the prominent rules that have already been studied.

So here's an example rulestring: Bx1bc3acd8yd1e/C*0a3cx5-c/S*1bcd2bc3b

B indicates birth and S indicates survival as usual, and C indicates a change in state... x and y refer to the final state of the cell (1 or 2, respectively), so for example Bx indicates off cells becoming state 1 and Cy indicates state 1 cells becoming state 2. (Originally I wanted to use roman numerals i and ii, but that would create conflicts later on, it turns out...)

For each x transition, you have a bunch of segments that usually look a lot like Hensel notation of the form #___, where the number # is the number of state 1 cells and each letter _ is the number of state 2 cells (starting from a = 0, b = 1, c = 2, etc.). For y transitions numbers are state 2 and letters are state 1 — so the numbers are neighbors that are alike to the final state and the letters are neighbors that are the opposite live state from the final state.

Unlike Hensel notation, though, you can actually switch the numbers and letters if you want! So Bxa345 is an equally valid way of writing Bx3a4a5a (both representing birth of a state 1 cell on 3–5 state-1 neighbors and no state-2 neighbors, for instance — you just can't use both versions in the same segment. For example, if you wanted to specify that state 2 survives if it has either exactly one state-1 neighbor or exactly one state-2 neighbor but not both, you'd have to write Sy1-aya-1 (repeating the y).

Transitions are grouped at the smallest level in these Hensel-like units, then the final state (x or y), then type of transition (birth, state change, or survival) at the largest level (separated by / as usual).

Some more shortcuts exist:
  • Similar to INT rules one can use dashes to invert something (i.e. "all but ___"), but this time you can invert it at different levels or even multiple at once (Bx1-c, Bxc-1, Bx-3b, Bx-3, Bx-3-b, Bx-b, etc.).
  • Plain Sx or Sy (with nothing after it) mean every cell of that state survives, or similar for C transitions.
  • Things like Sx#23 (the hash mark in particular) mean those transitions are fully totalistic based on live neighbors, with no distinction between state-1 and state-2 neighbors. (Normal transitions can't follow # transitions within the same x/y block, so you could either write "state 2 becomes state 1 on two or three live neighbors, or four of each state", as Cx4e#23 or Cx#23x4e, but not as Cx#234e.)
  • B*3 or the like means * is standing in for both of x or y because both types of transitions are written the same — so something like B*2-cd5ad would be equivalent to Bx2-cd5ady2-cd5ad.
So for the example (Bx1bc3acd8yd1e/C*0a3cx5-c/S*1bcd2bc3b), you have:
  • Birth of state 1 on ((one state 1 cell) with (one or two state 2 cells)), ((three state 1 cells) with (zero, two, or three state 2 cells)), or eight state 1 cells; and birth of state 2 on ((one state 2 cell) and (three state 1 cells)) or four state 1 cells (regardless of state 2 cells);
  • If a cell of one state has zero live neighbors, or ((exactly two same-state neighbors) and (exactly three opposite-state neighbors)), or it is state 1 and has ((exactly five state-2 neighbors) and (anything but exactly two state-1 neighbors)) it becomes the other live state;
  • And if a cell has 1–3 of each type of neighbor and no more than 4 total live neighbors, it survives.
(I haven't actually looked at this rule at all, it's just an example of what a rulestring looks like.)

Some simpler examples with more well-known rules:
  • Immigration: B*2b3a/C/S*#23 — birth on three like neighbors or two like and one unalike; survival on two or three neighbors of any kind
  • Brian's Brain: Bx2/Cy/S — birth of state 1 on two state-1 neighbors (regardless of state-2 neighbors); state 1 always becomes state 2, which always dies
  • Symbiosis: B*3a/C/S*-a-23 — birth on three like neighbors and no unalike neighbors; always survive unless no unalike neighbors... unless two or three like neighbors (double inversion)
  • VN-B1x2S23: Bya/Cx1/Sx23 — birth of state 2 on one state-1 neighbor, state 2 becomes 1 on one state-1 neighbor, state 1 survives on two or three state-1 neighbors, all regardless of state-2 neighbors
  • MilhinSA: Bx0d1c/Cy/Sy1b2ab3a — birth of state 1 on three state-2 neighbors and no state-1 or two state-2 and one state-1; state 1 always becomes state 2; state 2 survives if two or three neighbors and at most one of those is state 1
  • MixedLifeSeeds: Bx2b3ay2a/C/Sx23 — birth of state 1 on three state-1 neighbors and no state-1 or two state-1 and one state-1; birth of state 2 on two state-2 neighbors and no state-1; state 1 survives on two or three state-1 neighbors, regardless of state-2 neighbors
  • Neutronium: Bx#3/Cy#8/Sx#23y — state 1 born on three live neighbors of any type, state 1 becomes state 2 on 8 live neighbors, state 1 survives on 2 live neighbors, state 2 always survives
Advantages of this notation:
  • At least for many commonly-studied rules it's probably the most compact 3-state OT rulestring notation that's been developed
  • Very good at conveying rules with certain types of state symmetries (including some well-studied ones like Generations and variants)
  • IMO it's easier to read than most other notations I've seen (still not totally easy, but I can't imagine it being possible to make something too much easier than this)
  • A lot of the syntax is fairly familiar, even if it has different meanings sometimes
  • Separators! Heterogeneity! Most of the time you can actually look at the middle of a rulestring and figure out what's going on, instead of having to go back to the beginning and read it all the way through to figure out which numbers/letters in the long string of uninterrupted decimal, hex, or base-64 digits mean what
  • It could also be a powerful tool for constructing rules (just like Hensel notation is for INT rulegolfing), since it breaks down the types of sets of transitions that can occur in 3-state OT in a reasonably intuitive framework
Disadvantages of this notation:
  • Still not totally easy to read, even though it's better than most
  • Not compatible with a lot of existing tools — case-sensitive (rip Catagolue), special characters, C is a bit of a conflict with Generations syntax
  • Hard to canonize algorithmically — you can define the canonical rulestring as the lexicographically earliest one at the shortest possible length, but computing what it is for a given rule seems very challenging in the general case
  • Doesn't enforce internal consistency — you can define a given transition to exist and not exist at once, or you can define a cell to become two different states at once, in several different ways without being (locally) syntactically invalid
  • In a few cases (like long strings of a0b1c2d3e4...) it still has the same garden path problem as a lot of the notations that lack separators entirely
  • Difficult to extend to more states (since there aren't any more obvious ordered sequences of characters to use after numbers and letters)
  • Very bad at conveying rules with certain other types of state symmetries (like plus minus rules, for instance)
  • Not supported by any program yet, or even a rule table generating script, since I'm too lazy and hate string manipulation too much to write and debug one
I probably made multiple mistakes somewhere in here, so please don't hesitate to ask if something doesn't seem right or if you're just confused for whatever reason, like I didn't explain well, which I probably didn't... (Also I'd be remiss if I didn't link xkcd 927 to call myself out.)
former username: A for Awesome
praosylen#5847 (Discord)

The only decision I made was made
of flowers, to jump universes to one of springtime in
a land of former winter, where no invisible walls stood,
or could stand for more than a few hours at most...

Post Reply