Rulesets with B0 - Zero neighbors required for birth

[MXMLLN]

I think I can optimize my code a bit I don't allow births of cells with zero live neighbors.
Is it worth it? Does anyone use B0?

I could only find one article in the Forum that mentions a B0 rule.
In it, KittyTac notes that that set of rules tend to be uninteresting, but explosive.
However, the person who originally made the post was quite taken with the ruleset. They seem to have a similar level of Life competency as I do, so I'm inclined to side with them and support the rule.

What does everyone think?

[confocaloid]

Note that this belongs to the Other Cellular Automata subforum, rather than "Patterns". "Patterns" is about B3/S23 only.

Rulesets with B0 have the property that for any finite pattern, the entire universe "blinks" between "almost entirely dead" and "almost entirely alive".
This can be worked around by emulating every such ruleset as two alternating rulesets; one applied on "even-to-odd" ticks and another on "odd-to-even" ticks.

These CA can be interesting, but also sometimes harder to understand and investigate. There are software tools with limited support for such CA, or with no support at all.

[MXMLLN]

Sounds like it's worth supporting then. Thanks again, Confocaloid.
If it's possible, please move the post to the correct subforum.

[pifricted]

For help for strobing rules(B0/D8 rulespace), you can see "Emulating B0 rules" part.

I think I can optimize my code a bit I don't allow births of cells with zero live neighbors.
Is it worth it? Does anyone use B0?

I could only find one article in the Forum that mentions a B0 rule.
In it, KittyTac notes that that set of rules tend to be uninteresting, but explosive.
However, the person who originally made the post was quite taken with the ruleset. They seem to have a similar level of Life competency as I do, so I'm inclined to side with them and support the rule.

What does everyone think?

Of course there are some interesting rules.See List of strobing rules.

[MXMLLN]

For help for strobing rules(B0/D8 rulespace), you can see "Emulating B0 rules" part

That saved me a lot of time. Thanks!

[confocaloid]

Sounds like it's worth supporting then. [...]

If you choose to work with a finite universe (e.g. a torus with "wraparound" across boundaries), then you might decide to avoid emulation with alternating rulesets, and just let the background blink. This might be a bit irritating if every generation is displayed, but it's possible to avoid blinking by showing every second generation instead.

Below is the result of converting the oscillator stamp collection from OCA:B017/S01 into a three-state cellular automaton, where cellstates 1 and 2 represent "dead" and "alive" respectively and follow B017/S01 literally, while cellstate 0 is a "permanent wall" cellstate that never changes.

WARNING: it blinks. Set an even step for better view.

Code: Select all

#C [[ STEP 2 ]]
x = 219, y = 192, rule = test_B017S01
219A$219A$219A$219A$219A$219A$219A$219A$219A$219A$12AB3AB202A$28A2B
24ABAB162A$12AB3AB11A2B189A$39AB4ABAB11AB160A$12ABABAB14AB8AB178A$31A
B26AB160A$16AB17A2B183A$34A2B183A$16AB202A$219A$219A$219A$219A$219A$
219A$219A$219A$12ABABAB14A5B13A2B168A$31A5B13A2B4A2B162A$12AB3AB38A2B
59ABABAB2ABABAB39A2B50A$28A2B137A2B50A$12ABABAB11A2B6AB16AB62AB3AB2AB
95A$36AB2A2B10AB167A$12AB3AB22A2B75ABABAB2ABABAB91A$48A2B112A2B55A$
12ABABAB16A5B10A2B4A2B64AB2AB3AB34A2B55A$33A5B16A2B163A$116ABABAB2ABA
BAB42A2B47A$170A2B47A$219A$219A$219A$219A$219A$219A$219A$219A$219A$
28AB9AB180A$219A$28AB9AB180A$9AB2ABABAB148ABAB51A$31AB187A$9AB2AB18AB
134A2B51A$219A$9AB2ABABAB202A$31AB187A$9AB2AB3AB14AB187A$162A2B55A$9A
B2ABABAB11AB9AB123A2B55A$219A$28AB9AB131A2B47A$124A2B22A2B20A2B47A$
124A2B22A2B69A$156AB62A$116A2B36AB64A$116A2B8ABAB25AB64A$128AB27AB62A
$28AB21AB75AB92A$153A2B64A$28AB21AB33AB36A2B22A2B72A$9ABABAB2ABABAB
43ABAB19AB34A2B22A2B6ABAB63A$31AB30AB5AB11AB5ABAB4A2B124A$13AB6AB10AB
30ABABABAB19AB4A2B124A$76AB5AB7AB128A$9ABAB4ABABAB38A2B15AB97A2B22A2B
19A$31AB27A3B2ABABAB19ABAB83A2B22A2B19A$13AB2AB14AB36AB13AB3ABAB130A$
64ABAB10A3B6AB83AB48A$9ABABAB2ABABAB7AB21AB26A3B4AB83AB7ABAB40A$168AB
AB7AB24A2B14A$28AB21AB125AB26A2B14A$219A$171A2B22A2B22A$149A2B20A2B
22A2B22A$149A2B68A$219A$60A7B90A2B60A$28A2B30A7B90A2B60A$28A2B30A7B
152A$10ABABAB2AB3AB20A3B15A6B153A$42A3B15A6B12A3B138A$10AB6AB3AB20A3B
15A6B11A4B138A$60A6B11A4B138A$10ABABAB2ABABAB28A2B9A5B6AB4A3B139A$45A
B4A2B10A3B3AB13ABAB134A$10AB3AB6AB19AB3AB38AB134A$27A2B49AB140A$10ABA
BAB6AB5A2B49AB5AB134A$80AB138A$37A3B42ABAB3A2B129A$37A3B32AB15A4B60AB
AB64A$88A4B127A$88A4B61A2B64A$219A$219A$219A$219A$149A2B68A$149A2B68A
$219A$157A2B60A$157A2B60A$219A$30AB33AB154A$219A$30AB33AB87A2B65A$10A
B2AB2ABABAB131A2B65A$33AB185A$10AB2AB6AB12AB185A$219A$10AB2AB2ABABAB
198A$33AB185A$10AB2AB2AB16AB185A$219A$10AB2AB2ABABAB9AB33AB154A$219A$
30AB33AB154A$219A$219A$219A$219A$219A$219A$121AB2ABABAB2ABABAB83A$
219A$121AB6AB2AB3AB83A$219A$121AB2ABABAB2ABABAB83A$219A$121AB2AB6AB3A
B19A2B62A$155A2B62A$56A2B63AB2ABABAB2ABABAB11A2B70A$56A2B89A2B70A$
219A$219A$10AB2AB2ABABAB29A2B167A$39A2B9A2B167A$10AB2AB2AB22A2B178A$
54AB88A2B74A$10AB2AB2ABABAB16AB9AB4AB90A2B74A$35AB3ABABABAB6AB8A2B80A
2B74A$10AB2AB2AB3AB9A2B3AB3ABABABABAB6AB6A2B156A$30A2B5AB181A$10AB2AB
2ABABAB28A2B168A$44A2B3A2B7A2B159A$44A2B7A2B164A$53A2B5AB158A$34A2B
183A$34A2B6A2B14AB160A$42A2B102A2B71A$54A2B90A2B2A2B67A$39AB14A2B6A2B
82A2B71A$62A2B88AB66A$37AB5A2B174A$43A2B7A2B96A2B67A$38A2B7A2B3A2B
165A$47A2B170A$60AB5A2B151A$35A2B6AB6ABABABABAB3AB3A2B151A$35A2B8AB6A
BABABAB3AB91A2B63A$45AB4AB9AB92A3B63A$43AB109A2B64A$57A2B160A$46A2B9A
2B160A$46A2B171A$219A$219A$40A2B177A$40A2B177A$219A$219A$219A$219A$
219A$219A$219A$219A$219A$219A$219A$219A!

@RULE test_B017S01

@TABLE

n_states:3
neighborhood:Moore
symmetries:permute

1, 1,1,1,1,1,1,1,1, 2   # B0
1, 2,1,1,1,1,1,1,1, 2   # B1
1, 2,2,2,2,2,2,2,1, 2   # B7
2, 2,2,1,1,1,1,1,1, 1   # D2
2, 2,2,2,1,1,1,1,1, 1   # D3
2, 2,2,2,2,1,1,1,1, 1   # D4
2, 2,2,2,2,2,1,1,1, 1   # D5
2, 2,2,2,2,2,2,1,1, 1   # D6
2, 2,2,2,2,2,2,2,1, 1   # D7
2, 2,2,2,2,2,2,2,2, 1   # D8

For comparison, here is the original stamp collection as a two-state RLE:

Code: Select all

x = 196, y = 170, rule = B017/S01
3bo3bo$19b2o24bobo$3bo3bo11b2o$30bo4bobo11bo$3bobobo14bo8bo$22bo26bo$
7bo17b2o$25b2o$7bo9$3bobobo14b5o13b2o$22b5o13b2o4b2o$3bo3bo38b2o59bob
obo2bobobo39b2o$19b2o137b2o$3bobobo11b2o6bo16bo62bo3bo2bo$27bo2b2o10b
o$3bo3bo22b2o75bobobo2bobobo$39b2o112b2o$3bobobo16b5o10b2o4b2o64bo2bo
3bo34b2o$24b5o16b2o$107bobobo2bobobo42b2o$161b2o10$19bo9bo2$19bo9bo$o
2bobobo148bobo$22bo$o2bo18bo134b2o2$o2bobobo$22bo$o2bo3bo14bo$153b2o$
o2bobobo11bo9bo123b2o2$19bo9bo131b2o$115b2o22b2o20b2o$115b2o22b2o$147b
o$107b2o36bo$107b2o8bobo25bo$119bo27bo$19bo21bo75bo$144b2o$19bo21bo33b
o36b2o22b2o$obobo2bobobo43bobo19bo34b2o22b2o6bobo$22bo30bo5bo11bo5bob
o4b2o$4bo6bo10bo30bobobobo19bo4b2o$67bo5bo7bo$obo4bobobo38b2o15bo97b2o
22b2o$22bo27b3o2bobobo19bobo83b2o22b2o$4bo2bo14bo36bo13bo3bobo$55bobo
10b3o6bo83bo$obobo2bobobo7bo21bo26b3o4bo83bo7bobo$159bobo7bo24b2o$19b
o21bo125bo26b2o2$162b2o22b2o$140b2o20b2o22b2o$140b2o2$51b7o90b2o$19b2o
30b7o90b2o$19b2o30b7o$bobobo2bo3bo20b3o15b6o$33b3o15b6o12b3o$bo6bo3bo
20b3o15b6o11b4o$51b6o11b4o$bobobo2bobobo28b2o9b5o6bo4b3o$36bo4b2o10b3o
3bo13bobo$bo3bo6bo19bo3bo38bo$18b2o49bo$bobobo6bo5b2o49bo5bo$71bo$28b
3o42bobo3b2o$28b3o32bo15b4o60bobo$79b4o$79b4o61b2o5$140b2o$140b2o2$148b
2o$148b2o2$21bo33bo2$21bo33bo87b2o$bo2bo2bobobo131b2o$24bo$bo2bo6bo12b
o2$bo2bo2bobobo$24bo$bo2bo2bo16bo2$bo2bo2bobobo9bo33bo2$21bo33bo7$112b
o2bobobo2bobobo2$112bo6bo2bo3bo2$112bo2bobobo2bobobo2$112bo2bo6bo3bo19b
2o$146b2o$47b2o63bo2bobobo2bobobo11b2o$47b2o89b2o3$bo2bo2bobobo29b2o$
30b2o9b2o$bo2bo2bo22b2o$45bo88b2o$bo2bo2bobobo16bo9bo4bo90b2o$26bo3bo
bobobo6bo8b2o80b2o$bo2bo2bo3bo9b2o3bo3bobobobobo6bo6b2o$21b2o5bo$bo2b
o2bobobo28b2o$35b2o3b2o7b2o$35b2o7b2o$44b2o5bo$25b2o$25b2o6b2o14bo$33b
2o102b2o$45b2o90b2o2b2o$30bo14b2o6b2o82b2o$53b2o88bo$28bo5b2o$34b2o7b
2o96b2o$29b2o7b2o3b2o$38b2o$51bo5b2o$26b2o6bo6bobobobobo3bo3b2o$26b2o
8bo6bobobobo3bo91b2o$36bo4bo9bo92b3o$34bo109b2o$48b2o$37b2o9b2o$37b2o
3$31b2o$31b2o!

[MXMLLN]

Doing more research on Strobing rules and experimenting in Golly, it turns out that I don't really understand what's happening at all.

What size area do the rules run in?

I'm assuming the grid size grows once a cell is born beyond it, but I cannot guess at the exact equation. Technically, the area could also contract. Thus, it's important to know how others have dealt with B0 in the past.

Where would I find the formular for calculating the area size at each step in a Ruleset that allows births with zero neighbors?

Code: Select all

x = 3, y = 3, rule = B023/S23
o$3o$bo

[confocaloid]

Please don't use the "LV" tags without necessity. It leads to a viewer that's shown by default and consumes vertical space on the page.
The preferred way of sharing patterns is via the "pattern" button / "pattern" tags.

Doing more research on Strobing rules and experimenting in Golly, it turns out that I don't really understand what's happening at all.
[...]
Where would I find the formular for calculating the area size at each step in a Ruleset that allows births with zero neighbors?
[...]

If you are planning to emulate a B0/D8 ruleset through a pair of alternating non-B0 rulesets, then there is not much difference between that and just running two arbitrary non-B0 rulesets (one to go from an even generation to an odd generation, and another to go from an odd generation to an even generation).

It is unnecessary to calculate areas.

Imagine and think what exactly happens, if the rules "B023/S23" are applied literally at every tick, but (solely for display purposes) every odd generation (T = 1, T = 3, T = 5, ...) is inverted before showing it to the user.

Then, think what exactly happens if this "display only" trick is instead replaced by a change of the underlying model, where a single ruleset (B023/S23) is replaced by a pair of alternating rulesets:

The tick from T = 0 to T = 1 would be "apply rules B023/S23, and then invert the state of every cell in the universe".
The tick from T = 1 to T = 2 would be "invert the state of every cell in the universe, and then apply rules B023/S23".
Subsequent ticks would continue alternating in the same way.

The tick from T = 0 to T = 1 can be rewritten simply as following the rules "B145678/S0145678" instead. (A cell lives in the next generation if and only if it would not do so under B023/S23.)
The tick from T = 1 to T = 2 can be rewritten simply as following the rules "S865/B65" instead. (Birth on N alive neighbours is replaced by survival on 8-N alive neighbours. Survival on N alive neighbours is replaced by birth on 8-N alive neighbours.)

Compare the built-in LifeViewer emulation against an explicitly written pair of alternating rulesets:

Code: Select all

x = 3, y = 3, rule = B023/S23
o$3o$bo!

Code: Select all

x = 3, y = 3, rule = B145678/S0145678|S865/B65
o$3o$bo!

[MXMLLN]

Thanks for breaking down that part of the algorithm, Confocaloid.
I did scan through the Golly "Emulating B0 rules" page and the List of Strobing Rules that Pifricted posted.

NOW, I'm even more confused.
From your explanation, I can see why the pattern's height and width can effectively be ignored. However, what that leads to is an area that is not rectangular in shape.
Compare R-Pentomino T=0 to the next time step generation (T=1)

Code: Select all

x = 5, y = 5, rule = B023/S23
o$3o$bo

Code: Select all

x = 5, y = 5, rule = B023/S23
3o$2bobo$2bobo$o3bo$b3o!

• If T=1 is going to be 5x5, why didn't the upper right corner cell with no neighbors come alive?

• With both patterns using a 5x5 grid, why doesn't the 3rd step above match the 2nd step below?

This way of handling strobing rules effectively eliminates B0 altogether.

[confocaloid]

[...] If T=1 is going to be 5x5, why didn't the upper right corner cell with no neighbors come alive? [...]
[...] This way of handling strobing rules effectively eliminates B0 altogether.

That cell would come alive, if the software followed B023/S23 literally.
But the software does emulation instead. So at T = 1,3,5,7, ... the entire universe is inverted relative to what it would be without emulation.

Yes, the idea of emulation via alternating rulesets is precisely to eliminate B0 altogether.

[...] With both patterns using a 5x5 grid, why doesn't the 3rd step above match the 2nd step below? [...]

What you did here was to copy an odd-numbered generation (T = 1), and paste it into an even-numbered generation (T = 0).

Since B0-but-not-S8 rulesets are emulated via pairs of distinct alternating non-B0 rulesets, the exact same pattern will evolve differently depending on whether it's pasted into an odd-numbered generation or an even-numbered generation.

In the first posted case ("the 3rd step above"), the evolution (counting from the R-pentomino) is "evolve 1 tick according to B145678/S0145678, then evolve 1 tick according to B56/S568, then evolve 1 tick according to B145678/S0145678".
In second posted case ("the 2nd step below"), the evolution (counting from the R-pentomino) is "evolve 2 ticks according to B145678/S0145678, then evolve 1 tick according to B56/S568".
So, evolutions are different, and resulting patterns are different.

Code: Select all

x = 5, y = 5, rule = B145678/S0145678|S865/B65
o$3o$bo

Code: Select all

x = 5, y = 5, rule = B145678/S0145678|S865/B65
3o$2bobo$2bobo$o3bo$b3o!

[MXMLLN]

Oh, wow!
This all still makes B0 look like a lie.
I'll have to continue looking through the strobing rules for examples of any actual births with zero neighbors.

In the meantime, I'm probably not going to allow these rulesets in my application.

[confocaloid]

Oh, wow!
This all still makes BE look like a lie.
I'll have to continue looking through the strobing rules for examples of any actual births with zero neighbors.

In the meantime, I'm probably not going to allow these rulesets in my application.

Yes, a number of existing software tools lack support / have limited support for strobing CA.
Such CA can still be interesting. For example, B0 makes it possible to have spaceships in CA using von Neumann neighbourhood (just the four orthogonal neighbours):

Code: Select all

#C Source: https://conwaylife.com/forums/viewtopic.php?f=11&t=2233
x = 5, y = 3, rule = B02/S0V
bobo2$2ob2o!

If you prefer to be able to see birth on zero neighbours, there's always the option of avoiding emulation and showing the "blinking". In Golly/LifeViewer, the built-in emulation can be "worked around" by creating a three-state ruletable (0 = never changes, 1 = dead, 2 = alive):

Code: Select all

x = 64, y = 64, rule = test_B023S23
.62A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$
64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$31AB32A$31A3B
30A$32AB31A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$
64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$64A$.62A!

@RULE test_B023S23

@TABLE

n_states:3
neighborhood:Moore
symmetries:permute

# birth rules:
1, 1,1,1,1,1,1,1,1, 2   # B0
1, 2,2,1,1,1,1,1,1, 2   # B2
1, 2,2,2,1,1,1,1,1, 2   # B3

# death rules:
2, 1,1,1,1,1,1,1,1, 1   # D0
2, 2,1,1,1,1,1,1,1, 1   # D1
2, 2,2,2,2,1,1,1,1, 1   # D4
2, 2,2,2,2,2,1,1,1, 1   # D5
2, 2,2,2,2,2,2,1,1, 1   # D6
2, 2,2,2,2,2,2,2,1, 1   # D7
2, 2,2,2,2,2,2,2,2, 1   # D8

[Naszvadi]

An oscillator having period 34:

Code: Select all

x = 17, y = 15, rule = test_B023S23
17B$BA13BAB$17B$17B$7B2AB2A5B$5B2A2BA7B$5B6A6B$5BAB4ABA4B$7B6A4B$8BA2B
2A4B$6B2AB2A6B$17B$17B$BA13BAB$17B!

@RULE test_B023S23

@TABLE

n_states:3
neighborhood:Moore
symmetries:permute

# birth rules:
1, 1,1,1,1,1,1,1,1, 2   # B0
1, 2,2,1,1,1,1,1,1, 2   # B2
1, 2,2,2,1,1,1,1,1, 2   # B3

# death rules:
2, 1,1,1,1,1,1,1,1, 1   # D0
2, 2,1,1,1,1,1,1,1, 1   # D1
2, 2,2,2,2,1,1,1,1, 1   # D4
2, 2,2,2,2,2,1,1,1, 1   # D5
2, 2,2,2,2,2,2,1,1, 1   # D6
2, 2,2,2,2,2,2,2,1, 1   # D7
2, 2,2,2,2,2,2,2,2, 1   # D8

[R2INT]

A somewhat interesting and new B0 rule that has a spaceship.

Code: Select all

x = 43, y = 26, rule = B01346/S0134
4bo6b2o2b2o$2bo9b4o$2b3o7b4o$13b2o8$bo4bo5b3o8bo5bo3bo4bo$bo4bo4bobob
o6b2o5b5o4b3o$11b5o5b3o5b5o4b4o$6bo4bobobo5b2o6bo3bo4b4o$6bo5b3o6bo17b
4o6$3bo$3b2o2$2o$bo!

It appears that it has not been investigated in Catagolue yet, so it must be new.

[Drelectron8]

A somewhat interesting and new B0 rule that has a spaceship.

Code: Select all

x = 43, y = 26, rule = B01346/S0134
4bo6b2o2b2o$2bo9b4o$2b3o7b4o$13b2o8$bo4bo5b3o8bo5bo3bo4bo$bo4bo4bobob
o6b2o5b5o4b3o$11b5o5b3o5b5o4b4o$6bo4bobobo5b2o6bo3bo4b4o$6bo5b3o6bo17b
4o6$3bo$3b2o2$2o$bo!

It appears that it has not been investigated in Catagolue yet, so it must be new.

Oh, a diagonal I found from a random soup!

Code: Select all

x = 5, y = 5, rule = B01346/S0134
3b2o$3bo$4bo$2o$obo!