Rule request thread

[tommyaweosme]

life but on b7 it makes a mouse cell which dies instantly and turns all life cells around it into mouse cells

life with deadly mice

[confocaloid]

Related discussion thread for the topic: viewtopic.php?f=12&t=6868

life but on b7 it makes a mouse cell which dies instantly and turns all life cells around it into mouse cells

life with deadly mice

Code: Select all

#C [[ GRID RANDOMIZE2 RANDWIDTH 160 RANDHEIGHT 120 RANDFILL 20 ]]
x = 1, y = 1, rule = LWDM204927v0
b!

@RULE LWDM204927v0

@TABLE
n_states:3
neighborhood:Moore
symmetries:permute

var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x

0, 1,1,1,1,1,1,1,0, 2
1, x1,x2,x3,x4,x5,x6,x7,2, 2
0, 1,1,1,0,0,0,0,0, 1
1, 1,1,1,0,0,0,0,0, 1
1, 1,1,0,0,0,0,0,0, 1
x, x1,x2,x3,x4,x5,x6,x7,x8, 0

edit: here is a variant where birth from three alive neighbours happens regardless of whether the remaining neighbours are "dead" or "mice", I'm not sure which variant was intended:

Code: Select all

#C [[ GRID RANDOMIZE2 RANDWIDTH 160 RANDHEIGHT 120 RANDFILL 20 ]]
x = 1, y = 1, rule = LWDM204927v1
b!

@RULE LWDM204927v1

@TABLE
n_states:3
neighborhood:Moore
symmetries:permute

var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x

var d={0,2}
var d1=d
var d2=d
var d3=d
var d4=d
var d5=d

0, 1,1,1,1,1,1,1,0, 2
1, x1,x2,x3,x4,x5,x6,x7,2, 2
0, 1,1,1,d1,d2,d3,d4,d5, 1
1, 1,1,1,0,0,0,0,0, 1
1, 1,1,0,0,0,0,0,0, 1
x, x1,x2,x3,x4,x5,x6,x7,x8, 0

[tommyaweosme]

b-hept is a spaceship

Code: Select all

x = 10, y = 11, rule = LWDM204927v1
3$4.2A$5.2A$4.2A$4.A!
@RULE LWDM204927v1

@TABLE
n_states:3
neighborhood:Moore
symmetries:permute

var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x

var d={0,2}
var d1=d
var d2=d
var d3=d
var d4=d
var d5=d

0, 1,1,1,1,1,1,1,0, 2
1, x1,x2,x3,x4,x5,x6,x7,2, 2
0, 1,1,1,d1,d2,d3,d4,d5, 1
1, 1,1,1,0,0,0,0,0, 1
1, 1,1,0,0,0,0,0,0, 1
x, x1,x2,x3,x4,x5,x6,x7,x8, 0

edit: b-synthesis of a loaf

Code: Select all

x = 32, y = 40, rule = LWDM204927v1
13.2A.A$14.3A$15.A29$30.2A$29.2A$30.2A$31.A2$2A$.2A$2A$A!

[hotcrystal0]

life but on b7 it makes a mouse cell which dies instantly and turns all life cells around it into mouse cells

life with deadly mice

That, rule, except mice follow B3/S2.

[tommyaweosme]

life but on b7 it makes a mouse cell which dies instantly and turns all life cells around it into mouse cells

life with deadly mice

That, rule, except mice follow B3/S2.

would this work?

Code: Select all

#C [[ GRID RANDOMIZE2 RANDWIDTH 160 RANDHEIGHT 120 RANDFILL 20 ]]
x = 160, y = 120, rule = LWB3S2DMv1
!
@RULE LWB3S2DMv1
@TABLE
n_states:3
neighborhood:Moore
symmetries:permute
var x={0,1,2}
var x1=x
var x2=x
var x3=x
var x4=x
var x5=x
var x6=x
var x7=x
var x8=x
var d={0,2}
var d1=d
var d2=d
var d3=d
var d4=d
var d5=d
var e={0,1}
var e1=e
var e2=e
var e3=e
var e4=e
var e5=e
var e6=e
0, 1,1,1,1,1,1,1,0, 2
1, x1,x2,x3,x4,x5,x6,x7,2, 2
0, 1,1,1,d1,d2,d3,d4,d5, 1
0, 2,2,2,e1,e2,e3,e4,e5, 2
1, 1,1,1,0,0,0,0,0, 1
1, 1,1,0,0,0,0,0,0, 1
2, 2,2,e1,e2,e3,e4,e5,e6, 2
x, x1,x2,x3,x4,x5,x6,x7,x8, 0

[islptng]

Langton's ant, but the moves are knightwise.

Details:
The ant have 8 directions to move.
Ant on a white grid makes a Fx turn.
Ant on a black grid makes a Bx turn.
The background is black.

EDIT: Reposting my notation used for knightwise turn, thanks to CARuler for KnightwiseGeometry:

Code: Select all

x = 71, y = 106, rule = KnightwiseGeometry
16.2G46.2H$16.G.G45.H.H$12.2G2.2G42.2H2.2H2.H.H$12.2G2.G.G41.2H2.H.H
2.H$16.2G46.2H2.H.H4$AC46.AC$AB46.AB23$17.J47.I$16.J.J45.I.I$12.2J2.J
.J41.2I2.I.I.I.I$12.2J2.J.J41.2I2.I.I2.I$17.J47.I2.I.I4$AC46.AC$AB46.
AB18$60.3K$60.K$60.3K.K.K$60.K4.K$60.K3.K.K3$60.2K$60.2K5$48.AC$48.AB
23$17.M47.L$16.M.M45.L.L$12.2M2.3M41.2L2.3L.L.L$12.2M2.M.M41.2L2.L.L
2.L$16.M.M45.L.L.L.L4$AC46.AC$AB46.AB!

[PiSpaceships]

I request a rule called 1eLife:
-State 1 cell is born if it has 3 living neighbors
-State 1 cell survives if it has 2 or 3 living neighbors
-State 1 turns dies by default
-State 2 cell is born if it has one state 2 neighbor in 1e position, which is the only living neighbor
-State 2 cell always turns into state 1 cell.

Living = state 1 or state 2

[unname4798]

I request a rule called 1eLife:
-State 1 cell is born if it has 3 living neighbors
-State 1 cell survives if it has 2 or 3 living neighbors
-State 1 turns dies by default
-State 2 cell is born if it has one state 2 neighbor in 1e position, which is the only living neighbor
-State 2 cell always turns into state 1 cell.

Living = state 1 or state 2

Did it in BETTERTABLE:

Code: Select all

@RULE 1eLife
@BETTERTABLE
n_states=3
1 0
2 1
neighborhood=Moore
symmetries=rotate90reflect
0 2,0,0,0,0,0,0,0 2
symmetries=permute
a:0,1,2
b:1,2
0 b,b,b,0,0,0,0,0 1
1 a,b,b,0,0,0,0,0 1
@NAMES
0 empty
1 Life
2 1e
@COLORS
0 0 0 0
1 255 255 255
2 127 127 127

I don't like rotate4reflect symmetry using the regular TABLE format.

[PiSpaceships]

1eLife request

Did it in BETTERTABLE:

Code: Select all

worsetable

I don't like rotate4reflect symmetry using the regular TABLE format.

Can you do it in table format so I can run it in LifeViewer and Golly?

[confocaloid]

I request a rule called 1eLife:
-State 1 cell is born if it has 3 living neighbors
-State 1 cell survives if it has 2 or 3 living neighbors
-State 1 turns dies by default
-State 2 cell is born if it has one state 2 neighbor in 1e position, which is the only living neighbor
-State 2 cell always turns into state 1 cell.

Living = state 1 or state 2

Note that the .rule filename must begin with an uppercase letter.
So it cannot be '1eLife' without going against the naming conventions and causing potential/actual problems with software support.

Code: Select all

#C [[ RANDOMIZE RANDWIDTH 32 RANDHEIGHT 24 RANDFILL 25 ]]
x = 1, y = 1, rule = TestingRequestFromPost205435
b!

@RULE TestingRequestFromPost205435

https://conwaylife.com/forums/viewtopic.php?p=205435#p205435
-State 1 cell is born if it has 3 living neighbors
-State 1 cell survives if it has 2 or 3 living neighbors
-State 1 turns dies by default
-State 2 cell is born if it has one state 2 neighbor in 1e position, which is the only living neighbor
-State 2 cell always turns into state 1 cell.

Living = state 1 or state 2

@TABLE
n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var a={1,2}
var b=a
var c=a
var p={0,1,2}
var q=p
var r=p
var s=p
var t=p
var u=p
var v=p
var w=p

# the rules implementing "State 1 cell is born if it has (precisely) 3 living neighbors":
0, a,b,c,0,0,0,0,0, 1
0, a,b,0,c,0,0,0,0, 1
0, a,b,0,0,c,0,0,0, 1
0, a,b,0,0,0,c,0,0, 1
0, a,b,0,0,0,0,c,0, 1
0, a,b,0,0,0,0,0,c, 1
0, a,0,b,0,c,0,0,0, 1
0, a,0,b,0,0,c,0,0, 1
0, 0,a,0,b,0,c,0,0, 1
0, 0,a,0,b,0,0,c,0, 1

# the rules implementing "State 1 cell survives if it has (precisely) 3 living neighbors":
1, a,b,c,0,0,0,0,0, 1
1, a,b,0,c,0,0,0,0, 1
1, a,b,0,0,c,0,0,0, 1
1, a,b,0,0,0,c,0,0, 1
1, a,b,0,0,0,0,c,0, 1
1, a,b,0,0,0,0,0,c, 1
1, a,0,b,0,c,0,0,0, 1
1, a,0,b,0,0,c,0,0, 1
1, 0,a,0,b,0,c,0,0, 1
1, 0,a,0,b,0,0,c,0, 1

# the rules implementing "State 1 cell survives if it has (precisely) 2 living neighbors"
1, a,b,0,0,0,0,0,0, 1
1, a,0,b,0,0,0,0,0, 1
1, a,0,0,b,0,0,0,0, 1
1, a,0,0,0,b,0,0,0, 1
1, 0,a,0,b,0,0,0,0, 1
1, 0,a,0,0,0,b,0,0, 1

1, p,q,r,s,t,u,v,w, 0 # the rule "State 1 dies by default"
0, 2,0,0,0,0,0,0,0, 2 # the rule "State 2 cell is born if it has one state 2 neighbor in 1e position, which is the only living neighbor"
2, p,q,r,s,t,u,v,w, 1 # the rule "State 2 cell always turns into state 1 cell."

[PiSpaceships]

I request a rule called 1eLife:
-State 1 cell is born if it has 3 living neighbors
-State 1 cell survives if it has 2 or 3 living neighbors
-State 1 turns dies by default
-State 2 cell is born if it has one state 2 neighbor in 1e position, which is the only living neighbor
-State 2 cell always turns into state 1 cell.

Living = state 1 or state 2

Note that the .rule filename must begin with an uppercase letter.
So it cannot be '1eLife' without going against the naming conventions and causing potential/actual problems with software support.

Code: Select all

rle

1. So I will rename it into LifePlus1e.
2. Thank you for the ruletable!

edit: If person A requests the rule and person B creates ruletable, what person "owns" the rule - person A or B?

[confocaloid]

[...] So I will rename it into LifePlus1e. [...]

Feel free to use/modify it. (If you change/add/remove any rules in the table, I suggest to double-check whether the comments still make sense, and update them as needed.)
It's just an attempt to implement the request (as far as I understood the request). No warranty express or implied ¯\_(ツ)_/¯

[unname4798]

edit: If person A requests the rule and person B creates ruletable, what person "owns" the rule - person A or B?

It's person A.

[hotcrystal0]

A multistate (preferrably <=4-state) rule where the “gLWSSider” works in all eight orientations:

GLWSSider:

Code: Select all

x = 3, y = 3, rule = MAPARYSfBIAtMAQYAiAAAAAgAFASmAAAIgAAJCoAIAAgABAACKACCAIAACAAIAAAAAAACAiAIAEgACAAAAAAAAAAA
bo$2bo$3o!

[R2INT]

A multistate (preferrably <=4-state) rule where the “gLWSSider” works in all eight orientations:
[...]

Here is a 4-state INT adaptation, with 3 2-state phases, 10 3-state phases, and 7 4-state phases.

Code: Select all

x = 18, y = 18, rule = GLWSSider4
5.2A4.2A$5.A.A2.A.A$5.A6.A3$3A12.3A$A16.A$.A14.A3$.A14.A$A16.A$3A12.3A
3$5.A6.A$5.A.A2.A.A$5.2A4.2A!
@RULE GLWSSider4
This is a 4-state INT adaptation by R2INT (requested by HotCrystal0) of a pattern from a MAP rule devised by AforAmpere.
@COLORS
0 0,0,0
1 255,255,255
2 0,255,255
3 255,0,255
@TABLE
n_states:4
neighborhood:Moore
symmetries:rotate4reflect
var a1 = {0,1,2,3}
var a2 = a1
var a3 = a1
var a4 = a1
var a5 = a1
var a6 = a1
var a7 = a1
var a8 = a1
var a9 = a1
1 2,0,2,0,0,0,0,0 0
0 0,1,1,1,0,0,0,0 1
1 1,1,0,0,1,0,0,0 1
1 1,0,1,0,0,0,0,0 1
0 1,1,0,1,0,0,0,0 1
1 1,1,0,1,0,0,0,0 1
1 1,0,1,1,0,0,0,0 2
1 1,1,0,0,0,0,0,0 1
0 1,0,1,1,0,0,0,0 1
0 1,1,1,0,0,0,0,0 1
0 0,1,2,1,0,0,0,0 2
2 1,1,0,0,1,0,0,0 1
1 1,0,2,0,0,0,0,0 1
0 1,2,0,1,0,0,0,0 1
1 1,2,0,1,0,0,0,0 1
1 1,0,1,2,0,0,0,0 2
0 2,1,1,0,0,0,0,0 2
0 1,0,1,2,0,0,0,0 1
0 0,1,2,2,0,0,0,0 1
2 2,0,0,0,1,0,0,0 2
2 2,0,0,0,0,0,0,0 1
0 1,0,0,1,2,2,0,0 1
1 1,2,0,0,0,0,0,0 2
1 1,0,2,1,0,0,0,0 1
1 0,1,2,1,0,0,0,0 1
0 1,2,1,0,0,0,0,0 1
1 2,1,0,0,0,0,0,0 1
1 1,1,0,1,1,0,0,0 1
1 1,1,0,0,2,0,0,0 2
0 0,2,1,1,0,0,0,0 2
0 1,1,1,1,2,0,0,0 2
1 0,1,1,1,0,0,0,0 3
1 1,2,0,0,1,0,0,0 3
2 1,1,0,0,2,0,0,0 3
0 1,1,2,2,0,1,1,0 1
1 1,0,0,1,0,0,0,0 1
0 1,3,1,0,0,0,0,0 1
1 1,1,0,0,0,2,0,0 1
0 2,0,1,1,0,0,0,0 1
1 1,3,0,0,0,0,0,0 1
0 0,1,0,0,0,2,0,0 1
1 1,0,0,0,1,0,0,0 2
1 1,1,1,0,0,0,0,0 1
1 1,2,1,0,0,0,0,0 3
1 2,0,0,0,1,0,0,0 1
0 3,0,1,1,0,0,0,0 3
1 1,0,0,3,0,0,0,0 1
1 1,0,0,2,0,0,0,0 1
1 1,0,3,2,0,0,0,0 2
0 2,3,1,0,0,0,0,0 2
0 1,0,3,2,0,0,0,0 1
0 2,0,1,2,0,0,0,0 1
1 2,1,0,0,0,2,0,0 1
1 0,1,3,1,0,0,0,0 1
1 3,1,0,0,0,2,0,0 1
0 2,0,1,3,0,0,0,0 1
1 1,3,0,1,0,0,0,0 1
2 2,0,1,1,0,0,0,0 2
2 2,1,0,0,0,0,0,0 1
0 2,2,1,0,0,0,0,0 1
1 1,3,0,2,0,0,0,0 1
3 1,2,0,0,1,0,0,0 3
0 1,1,2,2,0,3,1,0 1
1 3,0,0,1,0,0,0,0 1
0 0,1,3,1,0,0,0,0 1
1 3,0,2,0,0,0,0,0 1
0 1,0,1,3,0,0,0,0 2
2 1,3,0,0,1,0,0,0 1
2 1,3,0,2,0,0,0,0 1
1 2,0,3,1,0,0,0,0 3
3 1,1,0,0,1,0,0,0 2
1 1,0,3,0,0,0,0,0 2
1 1,3,0,0,1,0,0,0 1
0 2,2,1,1,1,0,0,0 1
1 0,1,1,2,0,0,0,0 3
1 2,2,0,0,0,0,0,0 2
2 3,0,0,1,0,0,0,0 1
3 1,2,0,0,2,0,0,0 2
0 0,1,3,2,0,0,0,0 2
# engineering...
0 1,2,0,2,0,0,0,0 1
2 1,0,2,0,1,0,0,0 3
2 0,1,2,1,0,0,0,0 1
1 2,2,1,0,0,0,0,0 1
0 1,1,3,0,0,0,0,0 2
0 3,2,1,0,0,0,0,0 1
2 1,0,0,1,0,0,0,0 1
1 2,3,0,0,0,0,0,0 2
1 1,3,2,0,0,0,0,0 1
2 1,0,0,2,0,0,0,0 1
0 1,0,2,0,2,1,0,0 1
1 0,2,0,0,0,1,0,0 1
0 1,0,1,0,1,2,0,0 1
# extra
1 0,1,0,0,0,1,0,0 1
1 0,1,0,1,0,1,0,0 1
1 1,0,1,0,1,0,0,0 1
1 1,0,1,0,0,1,0,0 1
1 1,1,0,0,0,1,0,0 1
1 1,0,0,1,0,1,0,0 1
0 0,1,0,1,0,1,0,0 1
0 1,0,1,0,1,0,0,0 1
0 1,0,1,0,0,1,0,0 1
0 1,1,0,0,0,1,0,0 1
0 1,1,0,0,1,0,0,0 1
0 1,0,0,1,0,1,0,0 1
# TL
1 1,1,3,0,0,0,0,0 2
1 0,2,0,2,0,0,0,0 1
0 2,0,1,0,2,0,0,0 2
3 1,0,0,0,1,0,0,0 2
0 1,3,0,0,2,0,0,0 1
0 1,0,2,1,0,0,0,0 1
2 1,0,0,1,0,1,0,0 1
2 1,0,0,0,1,0,0,0 1
0 0,2,1,2,0,0,0,0 1
1 2,0,0,0,2,0,0,0 1
# state 3 CGoL
0 0,3,0,3,0,3,0,0 3
0 3,0,3,0,3,0,0,0 3
0 3,0,3,0,0,3,0,0 3
0 3,3,3,0,0,0,0,0 3
0 0,3,3,3,0,0,0,0 3
0 3,3,0,3,0,0,0,0 3
0 3,0,3,3,0,0,0,0 3
0 3,3,0,0,0,3,0,0 3
0 3,3,0,0,3,0,0,0 3
0 3,0,0,3,0,3,0,0 3
3 0,3,0,3,0,0,0,0 3
3 3,0,3,0,0,0,0,0 3
3 3,0,0,3,0,0,0,0 3
3 3,3,0,0,0,0,0,0 3
3 3,0,0,0,3,0,0,0 3
3 0,3,0,0,0,3,0,0 3
3 0,3,0,3,0,3,0,0 3
3 3,0,3,0,3,0,0,0 3
3 3,0,3,0,0,3,0,0 3
3 3,3,3,0,0,0,0,0 3
3 0,3,3,3,0,0,0,0 3
3 3,3,0,3,0,0,0,0 3
3 3,0,3,3,0,0,0,0 3
3 3,3,0,0,0,3,0,0 3
3 3,3,0,0,3,0,0,0 3
3 3,0,0,3,0,3,0,0 3
a1 a2,a3,a4,a5,a6,a7,a8,a9 0

Is it possible to do it in 3 states?

[LuveelVoom]

Life, except if B7 is triggered a neutrino is created instead, which passes through everything and is traveling in the direction of the empty cell in the B7. If a neutrino encounters a cell which would trigger B5, B6, B7, or B8, it does so (turns the cell on) and destroys itself. Neutrinos can pass through one another, and they travel at the speed of light. I would also like a ruletable where neutrinos do not cause any interactions and just notate B7.

[confocaloid]

Life, except if B7 is triggered a neutrino is created instead, which passes through everything and is traveling in the direction of the empty cell in the B7. If a neutrino encounters a cell which would trigger B5, B6, B7, or B8, it does so (turns the cell on) and destroys itself. Neutrinos can pass through one another, and they travel at the speed of light. I would also like a ruletable where neutrinos do not cause any interactions and just notate B7.

Some clarification may help, should the rules be isotropic (so that patterns can be safely rotated/reflected) or non-isotropic? In the former case, an orthogonal neutrino would require at least two nonzero cells and a diagonal neutrino would require at least three nonzero cells. In the latter case, one could have separate cellstates for each of 8 directions so that every neutrino is a single nonzero cell.

Not obvious how to let neutrinos pass through each other, short of putting a separate "layer" for every direction (which would exceed the limit of 256 cellstates supported by the RuleLoader algorithm) or discovering rules such that every collision between 2 through 8 neutrinos correctly produces nothing but the same number of neutrinos moving "as if they passed through each other".

[LuveelVoom]

Some clarification may help, should the rules be isotropic (so that patterns can be safely rotated/reflected) or non-isotropic? In the former case, an orthogonal neutrino would require at least two nonzero cells and a diagonal neutrino would require at least three nonzero cells.

Yes, they should be isotropic. Maybe they can mutually annihilate instead of passing through each other.

[confocaloid]

Some clarification may help, should the rules be isotropic (so that patterns can be safely rotated/reflected) or non-isotropic? In the former case, an orthogonal neutrino would require at least two nonzero cells and a diagonal neutrino would require at least three nonzero cells.

Yes, they should be isotropic. Maybe they can mutually annihilate instead of passing through each other.

Linking a related idea (which doesn't really answer your request, though):
viewtopic.php?f=11&t=5895 "ChainedLife"

Unfortunately it looks like the rules prescribing when/how exactly a photon or a diaphoton will be created weren't fully written down in a human-readable way. But I just experimented a bit in Golly and found in all five variations small predecessors producing at least one photon and at least one diaphoton as they evolve:

Code: Select all

x = 7, y = 12, rule = ChainedLife1
5.2A$2.3A.A9$2A$2A!

Code: Select all

x = 5, y = 12, rule = ChainedLife2
3.2A$3A.A9$2A$2A!

Code: Select all

x = 3, y = 3, rule = ChainedLife3
2A$.2A$.A!

Code: Select all

x = 3, y = 3, rule = ChainedLife4
2A$.2A$.A!

Code: Select all

x = 5, y = 2, rule = ChainedLife5
3.2A$3A.A!

Introducing a series of rules that only very slightly modify the behavior of Life, allowing for a photon and a diaphoton to appear in some rare circumstances, namely by one particular birth condition that gives birth to a state 6 cell that behaves like a regular live cell, unless some other condition is met, which gives birth to a photon cell, which, in turn, produces 4 photons and 4 diaphotons.
[...]

[eRroR_6o6]

B3/S23, but it's an order-2 CA.

Definition of order-2 CA: https://en.wikipedia.org/wiki/Second-or ... _automaton

I've actually been trying to make a 4-state ruletable for this, but I don't really feel like wasting time confusing myself on how this actually should work alone, so I'll see if anyone else can waste time not confusing themselves on how this should work.

(If you're wondering, this was my closest attempt, until I realized that I had the definition of second-order CA completely wrong. Still interesting, though.)

Code: Select all

@RULE Second_Order_CA_Test

#C 0 is dead and was dead in the last generation
#C 1 is dead and was alive in the last generation
#C 2 is alive and was dead in the last generation
#C 3 is alive and was alive in the last generation

@COLORS
0 0 0 0
1 128 0 0
2 0 255 0
3 255 255 0

@TABLE
n_states:4
neighborhood:Moore
symmetries:permute

var e1 = {0,1,2,3}
var e2 = {0,1,2,3}
var e3 = {0,1,2,3}
var e4 = {0,1,2,3}
var e5 = {0,1,2,3}
var e6 = {0,1,2,3}
var e7 = {0,1,2,3}
var e8 = {0,1,2,3}

var a1 = {1,3}
var a2 = {1,3}
var a3 = {1,3}
var a4 = {1,3}
var a5 = {1,3}
var a6 = {1,3}
var a7 = {1,3}
var a8 = {1,3}

var b1 = {0,2}
var b2 = {0,2}
var b3 = {0,2}
var b4 = {0,2}
var b5 = {0,2}
var b6 = {0,2}
var b7 = {0,2}
var b8 = {0,2}

var c1 = {2,3}
var c2 = {2,3}
var c3 = {2,3}
var c4 = {2,3}
var c5 = {2,3}
var c6 = {2,3}
var c7 = {2,3}
var c8 = {2,3}

var d1 = {0,1}
var d2 = {0,1}
var d3 = {0,1}
var d4 = {0,1}
var d5 = {0,1}
var d6 = {0,1}
var d7 = {0,1}
var d8 = {0,1}

b1, d1,d2,d3,d4,d5,c1,c2,c3, 2
a1, d1,d2,d3,d4,d5,c1,c2,c3, 3
1, c1,c2,d1,d2,d3,d4,d5,d6, 2
1, c1,c2,c3,d1,d2,d3,d4,d5, 2
3, c1,c2,d1,d2,d3,d4,d5,d6, 3
3, c1,c2,c3,d1,d2,d3,d4,d5, 3
d1, e1,e2,e3,e4,e5,e6,e7,e8, 0
c1, e1,e2,e3,e4,e5,e6,e7,e8, 1

[CARuler]

its been done

[get_Snacked]

B3/S23, but it's an order-2 CA.

Definition of order-2 CA: https://en.wikipedia.org/wiki/Second-or ... _automaton

I've actually been trying to make a 4-state ruletable for this, but I don't really feel like wasting time confusing myself on how this actually should work alone, so I'll see if anyone else can waste time not confusing themselves on how this should work.

(If you're wondering, this was my closest attempt, until I realized that I had the definition of second-order CA completely wrong. Still interesting, though.)

is B1x2/S23V an example of a second-order cellular automaton? if it is, you can use things from its ruletable.
EDIT: i don't think it is. here's what i think LifeR should look like if i understand correctly.
for a generation t and a cell c, the state of c at gen t+1 is determined by performing the condition of c at gen t, onto c at gen t-1. so for Life, a cell's state in the next generation is determined by checking whether that same cell in the previous generation is on or off. if the cell was on, the cell will be on in the next generation if the cell in the current generation has 2 or 3 neighbours, and if the cell was off, the cell will be on in the next generation if the cell in the current generation has 3 neighbours.
the problem is running patterns one tick after the first generation--will the pattern just follow normal B3/S23 for the first tick? that would make sense so that everything could follow second-order B3/S23 for all ticks after.

[islptng]

is B1x2/S23V an example of a second-order cellular automaton? if it is, you can use things from its ruletable.

Unfortunately it's not. Firstly, it has 3 states, while there must be at least 4 in an implementation of a 2nd-order CA. Secondly, 2nd-order CA are reversible, but in B1x2/S23V, a single state 2 cell just dies, and dead cell keeps dead forever, which is not reversible.

The Rule Table Repository includes ReversibleLife by Paul Nasca. Get it here.

[R2INT]

B3/S23, but it's an order-2 CA.
[...]

Here is my interpretation:

Code: Select all

x = 24, y = 41, rule = SecondOrderLife
.C$2.C4$.B14.B4.A.B$B5.A3.CB3.B2A4.B3$CB$2.B$2.C4$.B3.B5.CB3.A$2.B4.B
$2.B2.B4.B4.BCB4$BAB$.2B4$2.C$CB5$.BC2.B.B3.A$5.C5.C$2.B8.B$11.B3$.B$
.AC$CB!
@RULE SecondOrderLife
@NAMES
0 currently dead, previously dead
1 currently alive, previously dead
2 currently dead, previously alive
3 currently alive, previously alive
@COLORS
0 0,0,0
1 228,255,255
2 48,0,0
3 255,255,255
@TABLE
n_states:4
neighborhood:Moore
symmetries:permute
var l1 = {1,3}
var l2 = l1
var l3 = l2
var l4 = l3
var l5 = l4
var l6 = l5
var l7 = l6
var l8 = l7
var d1 = {0,2}
var d2 = d1
var d3 = d2
var d4 = d3
var d5 = d4
var d6 = d5
var d7 = d6
var d8 = d7
# A0
2 d1,d2,d3,d4,d5,d6,d7,d8 1
# D0
1 d1,d2,d3,d4,d5,d6,d7,d8 2
3 d1,d2,d3,d4,d5,d6,d7,d8 3
# A1
2 l1,d1,d2,d3,d4,d5,d6,d7 1
# D1
1 l1,d1,d2,d3,d4,d5,d6,d7 2
3 l1,d1,d2,d3,d4,d5,d6,d7 3
# A2
2 l1,l2,d1,d2,d3,d4,d5,d6 1
# S2
1 l1,l2,d1,d2,d3,d4,d5,d6 3
3 l1,l2,d1,d2,d3,d4,d5,d6 2
# B3
0 l1,l2,l3,d1,d2,d3,d4,d5 1
2 l1,l2,l3,d1,d2,d3,d4,d5 0
# S3
1 l1,l2,l3,d1,d2,d3,d4,d5 3
3 l1,l2,l3,d1,d2,d3,d4,d5 2
# A4
2 l1,l2,l3,l4,d1,d2,d3,d4 1
# D4
1 l1,l2,l3,l4,d1,d2,d3,d4 2
3 l1,l2,l3,l4,d1,d2,d3,d4 3
# A5
2 l1,l2,l3,l4,l5,d1,d2,d3 1
# D5
1 l1,l2,l3,l4,l5,d1,d2,d3 2
3 l1,l2,l3,l4,l5,d1,d2,d3 3
# A6
2 l1,l2,l3,l4,l5,l6,d1,d2 1
# D6
1 l1,l2,l3,l4,l5,l6,d1,d2 2
3 l1,l2,l3,l4,l5,l6,d1,d2 3
# A7
2 l1,l2,l3,l4,l5,l6,l7,d1 1
# D7
1 l1,l2,l3,l4,l5,l6,l7,d1 2
3 l1,l2,l3,l4,l5,l6,l7,d1 3
# A8
2 l1,l2,l3,l4,l5,l6,l7,l8 1
# D8
1 l1,l2,l3,l4,l5,l6,l7,l8 2
3 l1,l2,l3,l4,l5,l6,l7,l8 3

[Yoel]

Unfortunately it looks like the rules prescribing when/how exactly a photon or a diaphoton will be created weren't fully written down in a human-readable way. But I just experimented a bit in Golly and found in all five variations small predecessors producing at least one photon

To me they are written down in a human-readable way. I've written all of them by hand. The first example, commented:

Code: Select all

@RULE ChainedLife0

@COLORS

0 0 0 0
1 255 255 255
2 255 0 0
3 0 255 0
4 255 255 0

@TABLE

# Copyright by Yoel Matveyev, 2022
# The GNU General Public License v3.0

n_states:5
neighborhood:Moore
symmetries:rotate4reflect

var i={0,4}
var j=i
var k=i
var l=i
var m=i
var n=i
var o=i
var p=i

var I={1,2,3}
var J=I
var K=I
var L=I
var M=I
var N=I
var O=I
var P=I

var a={0,1,2,3}
var b=a
var c=a
var d=a
var e=a
var f=a
var g=a
var h=a

var A={0,1,2,3,4}
var B=A
var C=A
var D=A
var E=A
var F=A
var G=A
var H=A
var X=A

# Life

# States 1,2 or 3 count as alive in birth (3 of them in any position) and survival (2 or 3 in any position) of state 1.

# States 0 or 4 count as dead, which means that state 4 neighbors don't interfere 
# with birth or survival of state 1 cells, just like the extra states in Generations rules.

# Patterns containing only states 0 and 1 are identical to CGOL. 

# To cause novel behavior, we must introduce state 2 or 3 cells from the start with.

0,I,j,K,l,M,n,o,p,1
0,i,J,k,l,m,N,o,P,1
0,I,j,k,L,m,N,o,p,1
0,i,J,K,L,m,n,o,p,1
0,I,J,K,l,m,n,o,p,1
0,I,j,K,l,m,n,o,P,1
0,I,j,k,L,m,n,O,p,1
0,I,j,k,L,M,n,o,p,1
0,I,J,k,L,m,n,o,p,1
0,I,j,k,L,m,n,o,P,1

1,I,j,K,l,M,n,o,p,1
1,i,J,k,l,m,N,o,P,1
1,I,j,k,L,m,N,o,p,1
1,i,J,K,L,m,n,o,p,1
1,I,J,K,l,m,n,o,p,1
1,I,j,K,l,m,n,o,P,1
1,I,j,k,L,m,n,O,p,1
1,I,j,k,L,M,n,o,p,1
1,I,J,k,L,m,n,o,p,1
1,I,j,k,L,m,n,o,P,1

1,I,j,K,l,m,n,o,p,1
1,i,J,k,L,m,n,o,p,1
1,I,j,k,L,m,n,o,p,1
1,I,J,k,l,m,n,o,p,1
1,i,J,k,l,m,N,o,p,1
1,I,j,k,l,M,n,o,p,1

# Photon

# State 2 (red) propagates as a 1-cell thin photon

0,2,b,c,d,e,f,g,h,2

# Diaphoton

# State 3 (green) propagates as a diaphoton

0,0,3,0,0,0,0,0,0,3
0,3,B,C,D,E,F,G,H,4

# Diaphoton birth

# Two diagonally clashing photons give birth to a green diaphotonic cell

0,2,C,2,D,E,F,G,H,3

# Clean up

# States 2 and 3 become 4 on the next step (like in Generations)
# State 4 always dies, as do any other state combinations not declared above

2,A,B,C,D,E,F,G,H,4
3,A,B,C,D,E,F,G,H,4
4,A,B,C,D,E,F,G,H,0
X,A,B,C,D,E,F,G,H,0

ChainedLife1 is conceptually different: states 1, 2, 3 and 5 are alive, and three of them in 3k position give birth to state 5:

Code: Select all

 0,I,j,k,L,m,n,O,p,5

Code: Select all

x = 24, y = 15, rule = ChainedLife1
5$6.A9.B$7.A9.C$5.A9.A!

In turn, state 5 with three state 1 cells in a 4q position gives birth to a photonic cell:

Code: Select all

0,i,5,k,l,1,1,1,p,2

Code: Select all

x = 7, y = 8, rule = ChainedLife1
2$4.E$2.A$2.2A!

Thus, a photon birth require a chain of state positions, namely 3k and 4q. It does naturally happen:

Code: Select all

x = 16, y = 14, rule = ChainedLife1
4$10.A$7.2A2.A$7.A.A$10.A$7.A2.A$6.A3.2A$8.A.2A!

The other rules are designed similarly, based on different positions triggering the birth of an extra state/photon.

The chain could be indefinitely long, in which case only extremely rare chains of events, memorized by extra states, would cumulatively cause behavior different from CGOL.