Rule request thread

[Moosey]

I'd like a rule with two non interacting universes-- a Wireworld one and a life one-- but there are a couple extra cells:
Mauve cells, when a life cell is born in them, create an electron head in the WW universe. (They then behave like electron tails until the life cell leaves.
Green cells become live life cells when an electron head hits them.

[dvgrn]

I'd like a rule with two non interacting universes-- a Wireworld one and a life one...

By "non-interacting" do you mean that they're in parallel universes, so to speak -- a Life glider could pass through a WireWorld wire without affecting it, for example? Or is it just that there's a single additional state for Life patterns, which will behave like Life in areas that contain only those cells?

The second option wouldn't need nearly as many states... but it sounds like you have plans to make nice clean transitions between Life signals and WireWorld signals, and vice versa. At least in the WW->B3/S23 direction that might be tricky if the WireWorld cells got in the way of the Life Cells.

I think the model involving parallel universes with mauve and green wormholes would be a 16-state rule:

0 WW empty, Life OFF cell
1 WW electron tail, Life OFF cell
2 WW electron head, Life OFF cell
3 WW wire, Life OFF cell
4 WW empty, Life ON cell
5 WW electron tail, Life ON cell
6 WW electron head, Life ON cell
7 WW wire, Life ON cell
8 mauve cell: Life OFF cell, WW wire
9 mauve cell: Life ON cell, WW electron tail
10 mauve cell: Life OFF cell, WW electron tail
11 mauve cell: Life ON cell also creates WW electron head
12 green cell: Life OFF cell, WW wire
13 green cell: Life ON cell, WW electron tail
14 green cell: Life OFF cell, WW electron head
15 green cell: WW electron head, also creates Life ON cell

Sound about right? [EDIT: fixed a few details.]

[Moosey]

I'd like a rule with two non interacting universes-- a Wireworld one and a life one...

By "non-interacting" do you mean that they're in parallel universes, so to speak -- a Life glider could pass through a WireWorld wire without affecting it, for example?
...
Sound about right? [EDIT: fixed a few details.]

Yes and yes

[bprentice]

Moosey,

Here is a five state Golly rule tree which implements a Wire World and Life rule:

Code: Select all

@RULE WW_LIFE

@TREE
num_states=5
num_neighbors=8
num_nodes=59
1 0 0 3 4 4
1 0 1 3 4 2
2 0 0 1 0 0
1 1 1 3 4 4
2 0 1 3 0 0
1 0 0 3 4 2
2 1 3 5 1 1
3 2 4 6 2 2
2 3 5 0 3 3
3 4 6 8 4 4
2 5 0 0 5 5
3 6 8 10 6 6
4 7 9 11 7 7
2 0 0 0 0 0
3 8 10 13 8 8
4 9 11 14 9 9
3 10 13 13 10 10
4 11 14 16 11 11
5 12 15 17 12 12
1 0 0 0 0 0
2 0 0 19 0 0
3 13 13 20 13 13
4 14 16 21 14 14
5 15 17 22 15 15
2 0 19 19 0 0
3 13 20 24 13 13
4 16 21 25 16 16
5 17 22 26 17 17
6 18 23 27 18 18
2 19 19 19 19 19
3 20 24 29 20 20
4 21 25 30 21 21
5 22 26 31 22 22
6 23 27 32 23 23
3 24 29 29 24 24
4 25 30 34 25 25
5 26 31 35 26 26
6 27 32 36 27 27
7 28 33 37 28 28
3 29 29 29 29 29
4 30 34 39 30 30
5 31 35 40 31 31
6 32 36 41 32 32
7 33 37 42 33 33
4 34 39 39 34 34
5 35 40 44 35 35
6 36 41 45 36 36
7 37 42 46 37 37
8 38 43 47 38 38
4 39 39 39 39 39
5 40 44 49 40 40
6 41 45 50 41 41
7 42 46 51 42 42
8 43 47 52 43 43
5 44 49 49 44 44
6 45 50 54 45 45
7 46 51 55 46 46
8 47 52 56 47 47
9 48 53 57 48 48

@COLORS
0 0 0 0
1 255 0 0
2 0 255 0
3 0 0 255
4 255 255 0

The Square Cell definition is:

j.png (129.49 KiB) Viewed 7997 times

To understand the design carefully read the thread:

viewtopic.php?f=11&t=3576

An example that converts a glider to an electron:

Code: Select all

x = 83, y = 52, rule = WW_LIFE
25.2A$24.A.A$9.A.A11.A6.2A2.2A$9.A2.A10.A2.A2.A2.A.2A$2A10.2A9.A6.2A
$2A8.A3.2A8.A.A$5.2A5.2A11.2A$4.A4.A2.A8.A$9.A.A10.2A$21.2A6$28.A.A
$29.2A$29.A5$36.A$37.2A$36.2A6$43.A.A$44.2A$44.A$46.D$46.D$46.D$46.
D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$46.D$
46.D$47.36D!

Play with the rule and see if you can construct a pattern that converts an electron to a glider.

Brian Prentice

[Moosey]

That rule is nice, but it's extremely difficult to turn WW signals into Life ones because the only way to do so is to put some sort of trigger next to the wire:

Code: Select all

x = 8, y = 16, rule = WW_LIFE
B$D$D$D$D$D$D$2D.2A$D2.2A$D$D$D$4.2A$4.A$5.3A$7.A!

The best I can think of would be this incomplete Electron-to-H...

Code: Select all

#C the H eater is to show which G we can safely use:
x = 22, y = 66, rule = WW_LIFE
18.2A$18.2A4$18.2A$19.A$19.3A44$.D$D.D$D.C$D.B$D.D$D.D$D.D$D.D.2A$D.D
.2A$D.D$D.D.2A$D.D.2A$D.D$D.D$D.D!

In which we have an extra g out, which must:
1. Go the long way around the wire, in the direction of the h,
2. Clean up
3. Restore the biblock


TL;DR:
That's nice, but I'd still like to see something a tad closer to what I asked for, which could utilize known dot-to-Gs like the ones mentioned here.

[bprentice]

Moosey,

Try using well placed wire cells to modify the behavior of Life.

Brian Prentice

[Moosey]

Moosey,

Try using well placed wire cells to modify the behavior of Life.

Brian Prentice

The best I could come up with was this trigger:

Code: Select all

x = 23, y = 16, rule = WW_LIFE
7.A$6.A.A$6.A2.A$7.2A4$3.D4.D3$D7.2A5.2D$7.A2.A4D.5DBC$D7.2A5.2D3$3.D
4.D!

EDIT:
Finally!

Code: Select all

x = 29, y = 43, rule = WW_LIFE
23.A$22.A.A$20.A2.A.A$19.A.2A2.3A$15.2A2.A3.2A3.A$15.2A3.3A2.3A$23.A.
A$22.A.A$23.A3$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.
D$2.D23.D$2.D10.D$2.D$2.D$2.D$2.D$2.D$3.D$3.D4.D3$D7.2A5.2D$7.A2.A4D.
5DBC$D7.2A5.2D3$3.D4.D$3.D!

p260 gun:

Code: Select all

x = 47, y = 46, rule = WW_LIFE
.A$2A$A.A$28.A$27.A.A$25.A2.A.A$24.A.2A2.3A$20.2A2.A3.2A3.A$20.2A3.3A
2.3A$28.A.A$27.A.A$28.A10.D$40.6D$39.D6.D$7.D38.D$7.D38.D$7.D38.D$7.D
38.D$7.D38.D$7.D38.D$7.D38.D$7.D38.D$7.D38.D$7.D38.D$7.D38.D$7.D38.D$
7.D38.D$7.D38.D$7.D23.D14.D$7.D10.D27.D$7.D38.D$7.D38.D$7.D38.D$7.D
38.D$7.D38.D$8.D37.D$8.D4.D32.D$46.D$46.D$5.D7.2A5.2D24.D$12.A2.A4D.
5DBC18D$5.D7.2A5.2D3$8.D4.D$8.D!

Repeat time = 125:

Code: Select all

x = 70, y = 43, rule = WW_LIFE
23.A$22.A.A$20.A2.A.A$19.A.2A2.3A$15.2A2.A3.2A3.A$15.2A3.3A2.3A$23.A.
A$22.A.A$23.A3$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.
D$2.D23.D$2.D10.D$2.D$2.D$2.D$2.D$2.D52.CB12D$3.D65.D$3.D4.D29.31D$
37.D$38.31D$D7.2A5.2D52.D$7.A2.A4D.5DBC46D$D7.2A5.2D3$3.D4.D$3.D!

[bprentice]

Moosey,

Good start! Now construct period 19, 23, 34, 38 and 41 guns.

Brian Prentice

[toroidalet]

Off-topic, but here's a repeat time 51 electron-G converter:

Code: Select all

x = 25, y = 30, rule = WW_LIFE
12.D$12.D$12.D$12.D.D$12.D$12.D$12.D$12.D$12.D$12.D$10.D.D$12.D$6.D4.
D$6.D4.D3$11.2A5.2D$2.2D6.A2.A4D.2DBCD$.D9.2A5.2D.B2.D$.D19.D2.D$.D
17.2D3.D$2.D3.D4.D6.D5.D$3.D2.D4.D7.3D2.D$4.D9.2D6.D.D$5.9D.7D2.D$14.
2D8.D$24.D$.23D$D$.15DBC6D!

The absolute minimum with this signal generator is 38, and with Moosey's is 37, but a lot more work is needed to get down there.

EDIT:
Finally!

Code: Select all

x = 29, y = 43, rule = WW_LIFE
23.A$22.A.A$20.A2.A.A$19.A.2A2.3A$15.2A2.A3.2A3.A$15.2A3.3A2.3A$23.A.
A$22.A.A$23.A3$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.
D$2.D23.D$2.D10.D$2.D$2.D$2.D$2.D$2.D$3.D$3.D4.D3$D7.2A5.2D$7.A2.A4D.
5DBC$D7.2A5.2D3$3.D4.D$3.D!

smaller:

Code: Select all

x = 27, y = 34, rule = WW_LIFE
23.D2$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D$2.D23.D
$2.D10.D$2.D$2.D$2.D$2.D$2.D$3.D$3.D4.D3$D7.2A5.2D$7.A2.A4D.5DBC$D7.
2A5.2D3$3.D4.D$3.D!

[Moosey]

Off-topic, but here's a repeat time 51 electron-G converter:

Code: Select all

x = 25, y = 30, rule = WW_LIFE
12.D$12.D$12.D$12.D.D$12.D$12.D$12.D$12.D$12.D$12.D$10.D.D$12.D$6.D4.
D$6.D4.D3$11.2A5.2D$2.2D6.A2.A4D.2DBCD$.D9.2A5.2D.B2.D$.D19.D2.D$.D
17.2D3.D$2.D3.D4.D6.D5.D$3.D2.D4.D7.3D2.D$4.D9.2D6.D.D$5.9D.7D2.D$14.
2D8.D$24.D$.23D$D$.15DBC6D!

lower population:

Code: Select all

x = 25, y = 30, rule = WW_LIFE
12.D$12.D$12.D$12.D.D$12.D$12.D$12.D$12.D$12.D$12.D$10.D.D$12.D$11.D$
6.D4.D3$11.2A5.2D$2.2D6.A2.A4D.2DBCD$.D9.2A5.2D.B2.D$.D19.D2.D$.D17.
2D3.D$2.D3.D4.D6.D5.D$3.D7.D7.3D2.D$4.D8.2D7.D.D$5.8D.8D2.D$13.2D9.D$
24.D$.23D$D$.15DBC6D!

Variants with more clearance, at no expense of repeat time:

Code: Select all

x = 23, y = 27, rule = WW_LIFE
11.D$11.D$11.D$11.D.D$11.D$11.D$11.D$11.D$11.D$11.D$9.D.D$11.D$10.D$
5.D4.D3$10.2A5.2D$.2D6.A2.A4D.3D$D9.2A5.2D.D$D19.2D$D16.3D2.D$.D3.D4.
D5.D5.D$2.D7.D6.3D2.D$3.D8.2D6.D.D$4.D2.5D.7D2.D$4.D.D5.2D8.D$5.D16.B
!

Code: Select all

x = 23, y = 27, rule = WW_LIFE
11.D$11.D$11.D$11.D.D$11.D$11.D$11.D$11.D$11.D$11.D$9.D.D$11.D$10.D$
5.D4.D3$10.2A5.2D$.2D6.A2.A4D.3D$D9.2A5.2D.D$D19.2D$D16.3D2.D$.D3.D4.
D5.D5.D$2.D7.D6.3D2.D$3.D8.2D6.D.D$4.8D.6D.D.D$12.2D5.D2.D$22.B!

p51 gun:

Code: Select all

x = 68, y = 33, rule = WW_LIFE
11.D$11.D$11.D.2A$10.ABADA$11.C$11.B$11.D$11.D$11.D$11.D$9.D.D29.7D$
11.D17.3DCB7D7.D$10.D10.2D5.D12.D2.D3.3D$5.BA.A.D12.5D2.11D2.D.D.D2.D
$8.A20.D13.D.D.D.3D$4.A25.10D3.D.D.D.D.D$4.A.A4.A5.2D21.D2.D2.D3.D$.
2D6.2A.A4D.2DBC18D3.D6.D$D3.A.A4.A5.2D.B22.D6.D$D3.A15.D21.3D5.D13.D$
D7.A8.3D22.D.D5.A$.D3.BA.A.D5.D26.D5.A.A4.12D$2.D7.D6.3D23.D.2D2.A.A
2.2D$3.D8.BD6.D22.D6.A6.D$4.7DC.7D23.D$12.BD29.D$42.D$41.D4.D7.D$42.
2D$44.D$45.D4.D$46.D3.D$47.3D!

[nolovoto]

A little while ago I came up with this idea for a rule

2-state live/dead
Each dead cell scans 4 different 4x4 neighborhoods or "quadrants" where the origin point is within the middle 2x2 cells corresponding to each side.
The neighborhood with the most live cells applies the outer-totalistic rule to potentially become alive.
If 2 or more neighborhoods have the same number of live cells the rule the same outcome will happen because the same amount of cells will be involved.
Living cells will apply the same conditions for the survival portion of the rule.

Visualized example with a select cell within a pattern:

Code: Select all

 x = 25, y = 26, rule = LifeHistory
2$9.A$9.2A$9.ADA$11.2A5$10.C$10.C$5.EA2E.C.A3E3.C$5.E2AE.C.2A2E2.C$5.
EADA.C.ADAE.5C$5.3EA.C.2E2A2.C$10.C8.C$3.15C$10.C$5.E2AE.C.2A2E$5.EAD
A.C.ADAE$5.3EA.C.2E2A$5.4E.C.4E$10.C$10.C! 

[EvinZL]

Energetic except dead cells can't directly become whatever state 3 is called.

[wildmyron]

Energetic except dead cells can't directly become whatever state 3 is called.

You can just remove the block of lines starting with 0 and ending with 3 from the .rule file. Alternatively if you want to make other adjustments, you'll probably want to use the original .ruel file from here:
https://gist.github.com/apaap/1be76c8a4 ... getic-ruel
If you don't want to bother with getting Nutshell working, you can use this online version:
https://nutshell.pythonanywhere.com
Just remove this line from the .ruel file

Code: Select all

0, 1 ~ 3, 2 ~ 3, any-alive; 3

[EvinZL]

Energetic except dead cells can't directly become whatever state 3 is called.

You can just remove the block of lines starting with 0 and ending with 3 from the .rule file. Alternatively if you want to make other adjustments, you'll probably want to use the original .ruel file from here:
https://gist.github.com/apaap/1be76c8a4 ... getic-ruel
If you don't want to bother with getting Nutshell working, you can use this online version:
https://nutshell.pythonanywhere.com
Just remove this line from the .ruel file

Code: Select all

0, 1 ~ 3, 2 ~ 3, any-alive; 3

Nope, those caused those cells to become state 1 and that was exactly the new problem I created when trying to modify the rule.
EDIT: added

Code: Select all

0, 1, 2, 0; 0

and it worked.

[wildmyron]

Energetic except dead cells can't directly become whatever state 3 is called.

You can just remove the block of lines starting with 0 and ending with 3 from the .rule file. Alternatively if you want to make other adjustments, you'll probably want to use the original .ruel file from here:
https://gist.github.com/apaap/1be76c8a4 ... getic-ruel
If you don't want to bother with getting Nutshell working, you can use this online version:
https://nutshell.pythonanywhere.com
Just remove this line from the .ruel file

Code: Select all

0, 1 ~ 3, 2 ~ 3, any-alive; 3

Nope, those caused those cells to become state 1 and that was exactly the new problem I created when trying to modify the rule.
EDIT: added

Code: Select all

0, 1, 2, 0; 0

and it worked.

Sorry, I forgot about the need to suppress Birth in that instance. Glad you figured it out. And you've also used the state distribution feature of Nutshell (which is neat, but personally I prefer to allow only one state to be automatically distributed just to make it easier to remember what the line does!)

You might actually prefer to use

Code: Select all

0, 1 ~ 3, 2 ~ 3, any-alive; 0

which will also ensure that there's no Birth when there are photons adjacent to the cell (a pretty unlikely scenario, but just in case)

[Moosey]

would it be possible to make a TC and CU NTAA extension analogous to WWEJ3 or JVNWWE with a reasonable quantity of states?

[EvinZL]

would it be possible to make a TC and CU NTAA extension analogous to WWEJ3 or JVNWWE with a reasonable quantity of states?

What are TC, CU NTAA, WWEJ3, and JVNWWE? I think it's probably possible, depending on your definition of "reasonable".

[Moosey]

would it be possible to make a TC and CU NTAA extension analogous to WWEJ3 or JVNWWE with a reasonable quantity of states?

What are TC, CU NTAA, WWEJ3, and JVNWWE? I think it's probably possible, depending on your definition of "reasonable".

You're saying, "I don't know what half of that means, but yeah."
Okay then?

Anyways: Reasonable = <256 states.

TC = Turing complete
CU = construction universal
NTAA = NoTimeAtAll
JVNWWE = John von Neumann Wireworld extended, essentially a construction universal version of bliptile
WWEJ3 = a CU WireWorld variant

Re: how to make the rule, one could make it so that rather than XORing the signals, you just add their numbers together together. (With an ISOLATE state it wouldn't matter).
But I'd prefer this system, in which you could instead consider the codons as separate 0-1 pairs:
0-1
Add-subtract
Delete-Write
Isolate-Read
Left-Right
Then you could simply:
If the signals are part of the same pair, treat them like it would work in NTAA, and make the output the corresponding one in the pair
If the signals are not in the same a pair, treat them like it would work in NTAA, and make the output state 0 or state 1-- adding ISOLATE cells will help you get to the desired pair.)

I don't believe there is need for a toggle codon.

[muzik]

What is LogicRule from MCell's General Binary rule family expressed in hensel notation? Also, what are the MAP strings for Snowflakes and Sierpinski from the same rule family?

[dvgrn]

What is LogicRule from MCell's General Binary rule family expressed in hensel notation? Also, what are the MAP strings for Snowflakes and Sierpinski from the same rule family?

Ouch, that takes a little bit of translation. It's easy to get a 512-bit MAP-like string out of the LogicRule string:

Code: Select all

C0,NM,S256a, B3ababb5abaab4ab3ab23ab16ab14ab15ab32ab62ab63a
means
S
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
B
0001011000001001000010001000000000000000000000001000000000000000010000000000000010000000000000001000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000

so the full string is

00010110000010010000100010000000000000000000000010000000000000000100000000000000100000000000000010000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

But that can't be encoded directly into a MAP string, because the bits are all in the wrong order:

translation tables for MCell general binary and Golly/LifeViewer MAP format

translation-tables.png (16.34 KiB) Viewed 7537 times

So the first "0" is in the right place: it's in the 0th position, binary 000000000, and it just means "if all cells are off including the center cell, leave the center cell off". B0, basically.

The second "0" is in position 1, which is binary 000000001, so in MCell General Binary format it means "if there's just one ON neighbor to the north, everything else OFF, leave the center cell off." That corresponds to a 0 in the 128th position in the binary MAP string.

The third "0" is in position 2, which is binary 000000010, so in MCell General Binary format it means "if there's just one ON neighbor to the northeast, everything else off, leave the center cell off." That corresponds to a 1 in the 64th position of the MAP string.

There's a "1" in position 3, which is binary 000000011, so in MCell General Binary format it means "if there's an ON neighbor to the north and one to the northeast, everything else off, leave the center cell off." That corresponds to a 1 in the 128+64 = 192nd position of the MAP string.

... And so on. Somebody needs to write a quick conversion script to get the Snowflakes and Sierpinski MAP strings, I would think, but there are only thirteen 1s in the LogicRule string, so it should be pretty quick to figure out the Hensel notation from the positions of those 1s.

[JP21]

Can someone shrink this rule down? (Made on 12-4-19)

Code: Select all

@RULE 4-in-1v2x1
@TABLE
n_states:5
neighborhood:Moore
symmetries:permute
var a={0,1,2,3,4}
var a1={a}
var a2={a}
var a3={a}
var b={0,2,3,4}
var b1={b}
var b2={b}
var b3={b}
var b4={b}
var b5={b}
var b6={b}
var c={0,1,3,4}
var c1={c}
var c2={c}
var c3={c}
var c4={c}
var c5={c}
var d={0,1,2,4}
var d1={d}
var d2={d}
var d3={d}
var d4={d}
var d5={d}
var d6={d}
var e={0,1,2,3}
var e1={e}
var e2={e}
var e3={e}
var e4={e}
var e5={e}
var e6={e}
var e7={e}
var f={2,3,4}
var g={1,3,4}
var h={1,2,4}
var i={1,2,3}
var j={0,2}
var j1={j}
0,1,1,1,0,0,0,0,0,1
1,a,b,b1,b2,b3,b4,b5,b6,0
1,1,1,1,1,a,a1,a2,a3,0
1,1,1,a,b,b1,b2,b3,f,0
0,2,2,2,0,0,0,0,0,2
0,2,2,2,2,2,2,j,j1,2
2,a,a1,c,c1,c2,c3,c4,c5,0
2,2,2,2,2,2,c,c1,c2,0
2,2,2,2,a,c,c1,c2,g,0
2,2,2,2,2,2,2,a,g,0
0,3,3,3,0,0,0,0,0,3
0,3,3,3,3,3,3,0,0,3
0,3,3,3,3,3,3,3,3,3
3,a,d,d1,d2,d3,d4,d5,d6,0
3,3,3,3,d,d2,d3,d4,d5,0
3,3,3,3,3,3,3,a,a2,0
3,3,3,d,d1,d2,d3,d4,h,0
3,3,3,3,3,a,d,d1,h,0
0,4,4,4,0,0,0,0,0,4
0,4,4,4,4,4,4,0,0,4
4,e,e1,e2,e3,e4,e5,e6,e7,0
4,4,4,4,a,e,e1,e2,e3,0
4,4,4,4,4,4,4,a,a1,0
4,4,a,e,e1,e2,e3,e4,i,0
4,4,4,4,4,4,e,e1,i,0
@COLORS
1 0 255 0
2 0 255 255
3 255 128 0
4 255 255 0

[dvgrn]

Can someone shrink this rule down? (Made on 12-4-19)

Why does it need shrinking down? It looks reasonably compact for a four-in-one rule. In fact, it's a bit too compact, with no comments saying what the four states are emulating, or what exactly is supposed to happen when different states interact.

State 1 is B3/S23, and the others look familiar, too -- probably somebody here can recognize them right off, without analyzing the rule lines. State 3 is that rule where one phase of a glider becomes a p4 oscillator:

Code: Select all

x = 3, y = 3, rule = 4-in-1v2x1
.C$2C$C.C!

[JP21]

Can someone shrink this rule down? (Made on 12-4-19)

Why does it need shrinking down? It looks reasonably compact for a four-in-one rule. In fact, it's a bit too compact, with no comments saying what the four states are emulating, or what exactly is supposed to happen when different states interact.

State 1 is B3/S23, and the others look familiar, too -- probably somebody here can recognize them right off, without analyzing the rule lines. State 3 is that rule where one phase of a glider becomes a p4 oscillator:

Code: Select all

x = 3, y = 3, rule = 4-in-1v2x1
.C$2C$C.C!

The rule is simply this

Code: Select all

@RULE 4-in-1

@TABLE
n_states:5
neighborhood:Moore
symmetries:permute
#Life
0,1,1,1,0,0,0,0,0,1
1,0,0,0,0,0,0,0,0,0
1,1,0,0,0,0,0,0,0,0
1,1,1,1,1,0,0,0,0,0
1,1,1,1,1,1,0,0,0,0
1,1,1,1,1,1,1,0,0,0
1,1,1,1,1,1,1,1,0,0
1,1,1,1,1,1,1,1,1,0
#DayandNight
0,2,2,2,0,0,0,0,0,2
0,2,2,2,2,2,2,0,0,2
0,2,2,2,2,2,2,2,0,2
0,2,2,2,2,2,2,2,2,2
2,0,0,0,0,0,0,0,0,0
2,2,0,0,0,0,0,0,0,0
2,2,2,0,0,0,0,0,0,0
2,2,2,2,2,2,0,0,0,0
#These two at the bottom are switched in 4-in-1v2x1
#2x2
0,3,3,3,0,0,0,0,0,3
0,3,3,3,3,3,3,0,0,3
3,0,0,0,0,0,0,0,0,0
3,3,3,3,0,0,0,0,0,0
3,3,3,3,3,0,0,0,0,0
3,3,3,3,3,3,3,0,0,0
3,3,3,3,3,3,3,3,0,0
3,3,3,3,3,3,3,3,3,0
#MoveMorley
0,4,4,4,0,0,0,0,0,4
0,4,4,4,4,4,4,0,0,4
0,4,4,4,4,4,4,4,4,4
4,0,0,0,0,0,0,0,0,0
4,4,0,0,0,0,0,0,0,0
4,4,4,4,0,0,0,0,0,0
4,4,4,4,4,4,4,0,0,0
4,4,4,4,4,4,4,4,0,0
4,4,4,4,4,4,4,4,4,0

but if any of the four state cells touch a different state (not 0), it will die. I have seen some rules around the forums that are so complicated that I literally can't even understand it and it is compact. I think those were made by other (younger) people (maybe even entity valkyrie 2). I bet someone can shrink it down considerably like with less variables and using a different method of writing the rule.

[Hunting]

I need a B2n3/S23-qHistory rule.

[GUYTU6J]

I need a B2n3/S23-qHistory rule.

Dvgrn has made a script called isotropic-markedhistory-rule-gen.py, see https://github.com/dvgrn/b3s23life/blob ... ule-gen.py