LeapLife (B2n3/S23-q)

[JP21]

I love bad patterns.

Code: Select all

x = 135, y = 16, rule = B2n3/S23-q
127b2o$127b2o2bob2o$126bo4b2obo$111b2o13bo$2o109bo15b2o2b3o$bo60b2o48b
3o12b2o2bo2bo$bobo3b2o53b2o50bo10bobo5b2o$2b2o3b2o87b2o27b2o$96b2o$64b
2o48b3o$5b2o57b2o50bo$4bobo86b2o20bo12b3o$6bo3b2o47b2o31bobo35bo$10b2o
46bobo33bo4b2o28bo$60bo5b2o31b2o$66b2o!

[Hunting]

I love bad patterns.

Code: Select all

x = 135, y = 16, rule = B2n3/S23-q
127b2o$127b2o2bob2o$126bo4b2obo$111b2o13bo$2o109bo15b2o2b3o$bo60b2o48b
3o12b2o2bo2bo$bobo3b2o53b2o50bo10bobo5b2o$2b2o3b2o87b2o27b2o$96b2o$64b
2o48b3o$5b2o57b2o50bo$4bobo86b2o20bo12b3o$6bo3b2o47b2o31bobo35bo$10b2o
46bobo33bo4b2o28bo$60bo5b2o31b2o$66b2o!

Wow. It's so bad that the first is an example of an eater 1 usage (very nice considering no one have ever figured out how to use eater 1 as a catalyst in LeapLife), the second is a very useful component (extremely nice considering hook-adding reactions are rare here) and the last is the first low-period eater discovered after FWKnightship's ship-tie eater ( )

[dvgrn]

Speaking of LeapLife, when is somebody going to do the last round of construction-elbow research and build the Demonoid? I'm still kind of figuring that I did my part already, but there are a few good ways to move the project forward:

1) make single-glider Blockic seeds for guns of various periods. (Not sure this is too useful until it's decided what period the Demonoid will use.)
2) complete a toolkit of slow-salvo glider recipes for moving blocks and splitting one block into two, that can construct any well-spaced field of blocks.
3) write an slmake-like compiler that can produce a slow-salvo recipe for any well-spaced field of blocks, starting from a single block.

Later stages include deciding on an exact geometry for a Remini-like design that makes a construction arm out of two parallel intermittent streams of gliders (p44? p48?), and writing some search code to find a universal set of elbow-operation recipes that work with that construction arm.

[Hunting]

Speaking of LeapLife, when is somebody going to do the last round of construction-elbow research and build the Demonoid? I'm still kind of figuring that I did my part already, but there are a few good ways to move the project forward:

1) make single-glider Blockic seeds for guns of various periods. (Not sure this is too useful until it's decided what period the Demonoid will use.)
2) complete a toolkit of slow-salvo glider recipes for moving blocks and splitting one block into two, that can construct any well-spaced field of blocks.
3) write an slmake-like compiler that can produce a slow-salvo recipe for any well-spaced field of blocks, starting from a single block.

Later stages include deciding on an exact geometry for a Remini-like design that makes a construction arm out of two parallel intermittent streams of gliders (p44? p48?), and writing some search code to find a universal set of elbow-operation recipes that work with that construction arm.

Can you show me how to investigate slow salvo?

[dvgrn]

Can you show me how to investigate slow salvo?

Seems like you already have most of what you need. So far we've just tried to keep the technology simple, rather than doing anything crazy like trying for the absolute lowest-population Demonoid possible. So we have piles of one-time turners made out of well-separated blocks, that can easily handle all the timing adjustments we're going to need.

You already have most of the slow-salvo toolkit that you'll really need, posted here for example. The only thing I don't see there is a good slow salvo to push a block farther away. Is there a known recipe for that?

Then the idea is just to start figuring out how to string together whatever block-moving and block-splitting slow salvos you have, to build an arbitrary field of well-spaced blocks. Can you show that you can

start with one block
split it into two blocks
define one block as being in final position, and the other as the "hand" block that will be moved around
move the "hand" block to a safe distance from the block that's already in final position
split the "hand" block into two blocks
move one of the blocks into final position, maybe close to the previously placed block
... and repeat until the entire field of blocks has been placed.

Maybe you can find "edgy" block placement recipes that give you ideas about how to prove that you can do this algorithmically in some completely safe way, where placing a new block will never cause any trouble with blocks that have been placed already. Is there a way to "print" a block field by scanning line by line? Maybe scan diagonally, or even at an oblique angle? It will all depend on how "edgy" a recipe you can find to place blocks. Maybe two or more recipes will be needed.

A good way to go about it might be to find a very edgy block-splitting recipe. That way you never have to have extra blocks hanging around getting in the way. There's only the completed construction so far, plus one "hand" block. For each construction stage, you just move the hand block into the right position. Sending the block-split recipe will drop the next block into its final position in the block field, and leave a new hand block somewhere else at a safe distance.

[dvgrn]

Here's a quick example of the kind of block field I'm talking about, where we're going to need a script to create a slow-salvo recipe for it:

Code: Select all

x = 175, y = 163, rule = B2n3/S23-qHistory
2.A.A$3.2A$3.A12$131.AB$131.ABA$131.2A4$88.A$89.2A$88.2A26$117.2A$
117.2A3$110.2A$110.2A2$38.2A64.2A$38.2A7.2A50.2A3.2A$47.2A50.2A15.2A$
94.B16.2A3.2A$94.2A15.2A$94.2A3.2A$48.2A49.2A$42.2A4.2A$42.2A2$60.2A$
60.2A31.2A$88.2A3.2A$45.2A41.2A$45.2A27.2A$74.2A7.2A22.2A$83.2A3.2A
17.2A$88.2A$21.A24.2A2.2A$21.2A23.2A2.2A$20.A.A3$49.2A17.2A24.2A$49.
2A5.2A10.2A24.2A$56.2A4$57.2A2.2A$57.2A2.2A3$89.2A$60.2A27.2A$60.2A3$
88.2A2.2A$88.2A2.2A4$93.2A$81.2A10.2A5.2A$81.2A17.2A$63.2A$63.2A2$99.
2A2.2A$99.2A2.2A3$69.2A$50.2A17.2A3.2A28.2A$50.2A22.2A28.2A$120.A.A$
69.2A18.2A29.2A$64.2A3.2A18.2A30.A$64.2A$107.2A$101.2A4.2A$101.2A2$
58.2A$58.2A3.2A$46.2A15.2A37.2A$41.2A3.2A54.2A7.2A$41.2A15.2A51.2A$
53.2A3.2A$53.2A2$47.2A$47.2A3$40.2A$40.2A8$51.2A$50.2A$52.A17$2A$.2A
170.A$A171.2A$172.A.A!

It's very easy to take each of the pairs of input gliders in the four corners, and produce each pair from a single input glider plus a splitter and a few one-time turners. -- Or at least, anyone who wants to work on building a Demonoid but finds that this isn't easy... should practice until it is easy.

Probably it's mostly a matter of getting familiar with editing tools. I'd highly recommend Golly 4.0, since it can deal with "B2n3/S23-qHistory" with no need to install a separate rule file, and it becomes trivial to switch back and forth as needed between two-state and History or Super versions and adjust cell states, with Alt+G / Alt+H / Alt+J /Alt+K:

Code: Select all

x = 175, y = 163, rule = B2n3/S23-qSuper
2.O.O$3.2O$3.O12$131.SB$131.SBS$131.2S4$88.S$89.2S$88.2S26$117.2S$
117.2S3$110.2S$110.2S2$38.2O64.2S$38.2O7.2O50.2S3.2S$47.2O50.2S15.2S$
94.B16.2S3.2S$94.2S15.2S$94.2S3.2S$48.2O49.2S$42.2O4.2O$42.2O2$60.2O$
60.2O31.2S$88.2S3.2S$45.2O41.2S$45.2O27.2S$74.2S7.2S22.2S$83.2S3.2S
17.2S$88.2S$21.O24.2O2.2O$21.2O23.2O2.2O$20.O.O3$49.2O17.2O24.2S$49.
2O5.2O10.2O24.2S$56.2O4$57.2O2.2O$57.2O2.2O3$89.2Q$60.2O27.2Q$60.2O3$
88.2Q2.2Q$88.2Q2.2Q4$93.2Q$81.2Q10.2Q5.2Q$81.2Q17.2Q$63.2pA$63.2pA2$
99.2Q2.2Q$99.2Q2.2Q3$69.2pA$50.2pA17.2pA3.2pA28.2Q$50.2pA22.2pA28.2Q$
120.Q.Q$69.2pA18.2Q29.2Q$64.2pA3.2pA18.2Q30.Q$64.2pA$107.2Q$101.2Q4.
2Q$101.2Q2$58.2pA$58.2pA3.2pA$46.2pA15.2pA37.2Q$41.2pA3.2pA54.2Q7.2Q$
41.2pA15.2pA51.2Q$53.2pA3.2pA$53.2pA2$47.2pA$47.2pA3$40.2pA$40.2pA8$
51.2pA$50.2pA$52.pA17$2pA$.2pA170.Q$pA171.2Q$172.Q.Q!

Here's a LifeWiki tutorial showing one way to approach getting two synchronized gliders out of one glider. Again, the 90-degree Blockic LeapLife turners can be found here.

Once we get down to four gliders in the four quadrants, and those four are in turn all created from one initial input glider, that will be a Blockic seed for a p24 gun. We can easily build p48 gun seeds by connecting two p24 gun seeds with one more Blockic splitter. And from there it's just a short step to having a Blockic seed for a workable reflector / stream duplicator for a LeapLife Demonoid.

Side Note
The above is certainly not going to produce the smallest possible Blockic seed for a p24 gun. The project of finding a more efficient seed design is also left as an exercise for the reader.

[FWKnightship]

Code: Select all

x = 31, y = 31, rule = B2n3/S23-q
3o2b3o2bob2obo2b2o3bo6bo$2obobob3ob5ob3o2bob2o2b2o$ob2ob2ob5o2b5o3bo4b
2o$b2o4bo2b5obo3b4o2bo$4bo2b4obob3o2bob3o2b2o$3o7bobob3o2bo3bo5bo$obo
3bobobobob2obobo3b2o4bo$2ob2o2bob2o4bob2obo2b6obo$b2obobo2b4ob2o2b2o6b
2obo$b2obo2b2ob2o3bo2b3o5b2o$ob8o5bob2o2bobo3bo$b3o4b2ob5obobob2ob3ob
3o$7obo2bobo2b2o2b4o4b3o$2obo7b3obob4o2b2o3b2o$bob4obo2bo3bo2bo6b4o$3o
b8ob2ob2ob8ob3o$2b4o6bo2bo3bo2bob4obo$b2o3b2o2b4obob3o7bob2o$3o4b4o2b
2o2bobo2bob7o$3ob3ob2obobob5ob2o4b3o$3bo3bobo2b2obo5b8obo$3b2o5b3o2bo
3b2ob2o2bob2o$bob2o6b2o2b2ob4o2bobob2o$ob6o2bob2obo4b2obo2b2ob2o$bo4b
2o3bobob2obobobobo3bobo$bo5bo3bo2b3obobo7b3o$3b2o2b3obo2b3obob4o2bo$4b
o2b4o3bob5o2bo4b2o$b2o4bo3b5o2b5ob2ob2obo$b2o2b2obo2b3ob5ob3obobob2o$o
6bo3b2o2bob2obo2b3o2b3o!

[Sarah]

Sorry if this is already known, but ships can eat gliders

Code: Select all

x = 11, y = 10, rule = B2n3/S23-q
8bobo$8b2o$9bo5$b2o$obo$2o!

[bubblegum]

Sorry if this is already known, but ships can eat gliders

Code: Select all

x = 11, y = 10, rule = B2n3/S23-q
8bobo$8b2o$9bo5$b2o$obo$2o!

Yes it's already known, but I accept your apology. :mrgreen:

[Sarah]

Random oscillator

Code: Select all

x = 6, y = 3, rule = B2n3/S23-q
2o2b2o$2o2b2o$2o2b2o!

[dvgrn]

Random oscillator...

Have a look at the "xp6" category for LeapLife soup search results on Catagolue:

https://catagolue.hatsya.com/census/b2n3s23-q/C1

That particular oscillator has been seen forty-seven million times, so it's probably not new to anyone reading this thread.

If the Catagolue page doesn't make sense, if you have questions about what the category columns mean, etc., please feel free to ask questions!

[Hunting]

A natural p4 oscillator documented nowhere:

Code: Select all

x = 7, y = 8, rule = B2n3/S23-q
2o$obo2bo$2b3obo$b2o$3b3o$4b2o$2o2b2o$2o!

I don't know who found it, its attribute page says:

Code: Select all

*** xp4_39ekki4z66w33 ***

What happened? Is it possible to retrieve the discoverer?

[Hunting]

The only thing I don't see there is a good slow salvo to push a block farther away. Is there a known recipe for that?

Code: Select all

x = 213, y = 214, rule = B2n3/S23-q
o$b2o$2o98$102bo$103b2o$102b2o98$206bo$207b2o$206b2o10$211b2o$211b2o!

Here you go - but it is p6, which is probably not very good. It is produced by this very crude random slow salvo search script:

Code: Select all

from glife.base import *
import golly as g
import random

def collision (sirrobinsynth, bread):
    return (sirrobinsynth + glider (-8 + bread, -10, flip)) (100, 100)

g.setalgo("HashLife")
g.autoupdate(True)

while 1:
	bees = block
	g.setrule("B2n3/S23-q:P5000,5000")
	for i in range(3):
		bees = collision(bees, random.randint(-5, 5))
		bees.display("Slow Salvo Search")
		g.setstep(5)
		g.step()
		if g.empty():
			break
		g.reset()
	g.setrule("B2n3/S23-q")
	g.step()
	if int(g.getpop()) == 4:
		bruh = str(g.getrect()[0]) + str(g.getrect()[1]) + ".rle"
		g.reset()
		g.save(bruh, "rle")
g.setstep(0)

It produces very puzzling file name. EDIT: Fixed.

EDIT: Here's the manually-assembled result of a test run, I'll have it assemble the results on its own in the future.

Code: Select all

x = 1919, y = 221, rule = B2n3_S23-qHistory
A216.A210.A211.A211.A214.A213.A217.A$.2A215.2A209.2A210.2A210.2A213.
2A212.2A216.2A$2A215.2A209.2A210.2A210.2A213.2A212.2A216.2A98$107.A
204.A214.A217.A208.A214.A216.A209.A$108.2A203.2A213.2A216.2A207.2A
213.2A215.2A208.2A$107.2A203.2A213.2A216.2A207.2A213.2A215.2A208.2A
98$203.A211.A217.A206.A218.A213.A206.A218.A$204.2A210.2A216.2A205.2A
217.2A212.2A205.2A217.2A$203.2A210.2A216.2A205.2A217.2A212.2A205.2A
217.2A$1497.2D$1497.2D3$1711.2D$202.2D1507.2D$202.2D864.2D$1068.2D2$
213.2C211.2C211.2C211.2C211.2C211.2C211.2C211.2C211.2C$213.2C211.2C
211.2C211.2C211.2C211.2C2.2D207.2C211.2C211.2C$1282.2D$637.2D$419.2D
216.2D$419.2D2$854.2D$854.2D!

One p1 push. Some are trivial combinations of 1-glider push, I didn't bother filtering them out.

EDIT: I also ran some 4 glider search. Here is my search result (some might be tub, sorry for that):

nontoolkit.rar

(5.71 KiB) Downloaded 114 times

[Hunting]

b2n3s23-q/C1 (69 billion objects)

Also, ikpx2_stdin is the only symmetry that have:

Code: Select all

x = 0, y = 0, rule = B2n3/S23-q
3b3ob3o2$3bobobobo$3bobobobo$4bo3bo$4obobob4o$3bobobobo$b3obobob3o
$2bo2bobo2bo$5bobo$o2bobobobo2bo$5bobo$bo3bobo3bo$2b3o3b3o$4b2ob2o
$bo9bo$3o2bobo2b3o$b2o2bobo2b2o$5bobo$4obobob4o$2bobo3bobo$3b2o3b
2o2$2bo7bo$5bobo$2b3o3b3o$2bobo3bobo$4bo3bo$3bobobobo$2b2o5b2o$2bo
7bo2$3bobobobo$2b2o5b2o$3bo5bo$b2o7b2o2$2bobo3bobo$3b2o3b2o2$b2obo
3bob2o$o2b2o3b2o2bo$2b2o5b2o$2b3o3b3o$2bobo3bobo$3bobobobo$2b2obob
ob2o$3bo5bo$2b2o5b2o2$4bo3bo$3bo5bo$3bo5bo2$5bobo$3bobobobo$3bobob
obo$3bobobobo$3bobobobo$bo3bobo3bo$2b2obobob2o$2b2obobob2o$5bobo$b
5ob5o$b2obo3bob2o$2bo3bo3bo$4bobobo$2bobo3bobo$bobo2bo2bobo$b3ob3o
b3o$2b2o5b2o$bo3b3o3bo$bo4bo4bo$bobo5bobo$5bobo$2bo3bo3bo!

[dvgrn]

Here you go - but it is p6, which is probably not very good...

I think those p6 oscillators are so common that it might well be worth supporting them as intermediate targets. It does make it a little more complicated to run the elbow, but really it's still pretty easy.

At least, if we go with the same general mechanism that Life self-constructors have, the elbow will be something stable like a block. To hit an intermediate-target p6 at the correct phase, you just have to wait 0, 1, 2, 3, 4, or 5 ticks before sending the recipe to produce the next glider from the elbow.

So we don't even have to rate all of the 90-degree outputs as having a timing of 0, 1, 2, 3, 4, or 5 (mod 6). Once the compiler script is written, we pretty much won't notice the intermediate p6 oscillators at all -- the recipes will Just Work. Could even handle higher-period oscillators as intermediates if that turns out to be useful.

The big advantage of having common p6 oscillators like this is that there are so many different ways to hit them. The search tree will end up with a very high branching factor compared to boring plain-vanilla Life, so on average it will take a lot fewer slow gliders to build things.

So... seems like the next step is to do whatever you can to do collect all the recipes that do (X, Y) block moves. Maybe make a huge stamp collection of hundreds or thousands of them, and then run them in LeapLifeHistory to find the edgy ones that move a block to the very edge of the reaction envelope. Half a dozen of those that place the block at different offsets, will probably be enough that you can prove it's possible to build any possible field of closely-spaced blocks. After that, it will be script-writing time!

[Entity Valkyrie 2]

b2n3s23-q/C1 (69 billion objects)

Also, ikpx2_stdin is the only symmetry that have:

Code: Select all

x = 0, y = 0, rule = B2n3/S23-q
3b3ob3o2$3bobobobo$3bobobobo$4bo3bo$4obobob4o$3bobobobo$b3obobob3o
$2bo2bobo2bo$5bobo$o2bobobobo2bo$5bobo$bo3bobo3bo$2b3o3b3o$4b2ob2o
$bo9bo$3o2bobo2b3o$b2o2bobo2b2o$5bobo$4obobob4o$2bobo3bobo$3b2o3b
2o2$2bo7bo$5bobo$2b3o3b3o$2bobo3bobo$4bo3bo$3bobobobo$2b2o5b2o$2bo
7bo2$3bobobobo$2b2o5b2o$3bo5bo$b2o7b2o2$2bobo3bobo$3b2o3b2o2$b2obo
3bob2o$o2b2o3b2o2bo$2b2o5b2o$2b3o3b3o$2bobo3bobo$3bobobobo$2b2obob
ob2o$3bo5bo$2b2o5b2o2$4bo3bo$3bo5bo$3bo5bo2$5bobo$3bobobobo$3bobob
obo$3bobobobo$3bobobobo$bo3bobo3bo$2b2obobob2o$2b2obobob2o$5bobo$b
5ob5o$b2obo3bob2o$2bo3bo3bo$4bobobo$2bobo3bobo$bobo2bo2bobo$b3ob3o
b3o$2b2o5b2o$bo3b3o3bo$bo4bo4bo$bobo5bobo$5bobo$2bo3bo3bo!

This still life has not appeared in any LeapLife soups:

Code: Select all

x = 11, y = 13, rule = B2n3/S23-q
2b2o3b2o$bo2bobo2bo$obobobobobo$obobobobobo$b2obobob2o$4bobo$4bobo$b2o
bobob2o$b2obobob2o$4bobo$b2obobob2o$bo2bobo2bo$3b2ob2o!

[Hunting]

Here you go - but it is p6, which is probably not very good...

I think those p6 oscillators are so common that it might well be worth supporting them as intermediate targets. It does make it a little more complicated to run the elbow, but really it's still pretty easy.

At least, if we go with the same general mechanism that Life self-constructors have, the elbow will be something stable like a block. To hit an intermediate-target p6 at the correct phase, you just have to wait 0, 1, 2, 3, 4, or 5 ticks before sending the recipe to produce the next glider from the elbow.

So we don't even have to rate all of the 90-degree outputs as having a timing of 0, 1, 2, 3, 4, or 5 (mod 6). Once the compiler script is written, we pretty much won't notice the intermediate p6 oscillators at all -- the recipes will Just Work. Could even handle higher-period oscillators as intermediates if that turns out to be useful.

The big advantage of having common p6 oscillators like this is that there are so many different ways to hit them. The search tree will end up with a very high branching factor compared to boring plain-vanilla Life, so on average it will take a lot fewer slow gliders to build things.

So... seems like the next step is to do whatever you can to do collect all the recipes that do (X, Y) block moves. Maybe make a huge stamp collection of hundreds or thousands of them, and then run them in LeapLifeHistory to find the edgy ones that move a block to the very edge of the reaction envelope. Half a dozen of those that place the block at different offsets, will probably be enough that you can prove it's possible to build any possible field of closely-spaced blocks. After that, it will be script-writing time!

We have one p1 push recipe now, so I'd prefer to first crawl, then run. That being said, I don't really know.

So... seems like the next step is to do whatever you can to do collect all the recipes that do (X, Y) block moves. Maybe make a huge stamp collection of hundreds or thousands of them

The above Slow Salvo Search seems to be really handy for this, but it could use some optimization. Not now. I'm working on the p22 elbow plain brute-force script.

EDIT: I completed the very brute-force elbow script, and did some experiments with p44 first. Unsurprisingly, there are very few options. Here is a (4, 5) pull - I really wish it was (4, 4) or (5, 5). And this rule is weirdly biased towards pull so I don't expect a push to be found in p44.

Code: Select all

x = 135, y = 134, rule = B2n3/S23-q
2o$2o9$12b2o$11b2o$13bo9$23b2o$22b2o$24bo20$45b2o$44b2o$46bo9$56b2o$
55b2o$57bo9$67b2o$66b2o$68bo9$78b2o$77b2o$79bo9$89b2o$88b2o$90bo20$
111b2o$110b2o$112bo9$122b2o$121b2o$123bo9$133b2o$132b2o$134bo!

Script:

Code: Select all

from glife.base import *
import golly as g
import random

vacuum = pattern("")
g.setalgo("HashLife")
g.autoupdate(True)

def dfs(depth, current):
	if depth == 15:
		current.display("Single-Channel Recipe Search")
		(block (g.getrect()[0]-11, g.getrect()[1]-10) + current).display("Single-Channel Recipe Search")
		if int(g.getpop()) == 9:
			return
		bread = g.getrect()[0]
		sinkship = g.getrect()[1]
		g.setstep(5)
		g.step()
		if int(g.getpop()) == 4:
			bruh = str(g.getrect()[0]-bread) + str(g.getrect()[1]-sinkship) + ".rle"
			g.reset()
			g.save(bruh, "rle")
		return
	dfs(depth+1, glider + current[44])
	dfs(depth+1, vacuum + current[44])
dfs(0, pattern("b2o$2o$2bo9$12b2o$11b2o$13bo9$23b2o$22b2o$24bo9$34b2o$33b2o$35bo!"))

Replace the last line pattern with glider to search p22.

[Hunting]

Like, research on Remini-like recipes to try to build a universal constructor arm? At least at the moment, it's probably at least a couple of orders of magnitude easier to come up with a universal construction toolkit based on p24 technology than p22 technology.

Ancient quote. Seemingly, nope. p48 is divisible by 6, which means there are less ways to crash a TL. Meanwhile, p44 is not. I strongly suspect p48 don't have such a toolkit - but p44 probably don't have either, I can't be sure now.

I discovered several good p44 pulls now. I expect a push to be harder to find, because the rule is severely biased toward pull.

A pull:

Code: Select all

x = 234, y = 233, rule = B2n3/S23-q
2o$2o9$12b2o$11b2o$13bo9$23b2o$22b2o$24bo9$34b2o$33b2o$35bo9$45b2o$44b
2o$46bo9$56b2o$55b2o$57bo75$133b2o$132b2o$134bo53$188b2o$187b2o$189bo
31$221b2o$220b2o$222bo9$232b2o$231b2o$233bo!

[Hunting]

3G to 3G with the help of Kittyst:

Code: Select all

x = 25, y = 26, rule = B2n3/S23-q
2bo$obo$b2o11$20bo$19bo$19b3o6$23bo$22b2o$22bobo$14b2o$14b2o!

[Hunting]

I discovered a third natural trivial p20 today:

Code: Select all

x = 16, y = 16, rule = B2n3/S23-q
oobobbobobbboooo$
obbbooobobooobbo$
ooobobobbobooooo$
bobooboooobbbobb$
oobbooobbooboooo$
bbobbobbbooboobb$
bboobobobboobooo$
bbobobbobboobooo$
ooobbbobobbobobo$
bbbobooboobobobb$
bbbboooboobobbbo$
bbooooobbboobobo$
oooooobboobobbbb$
bobbbobbboobobbo$
oboboobboooobbob$
boobbboobobooobo!

Code: Select all

*** xp20_0c89aaczoi453 ***
Soup k_P7rnzySptruY993376 was found on 2020-12-01 at 08:40:02 UTC and is owned by Hunting

[Hunting]

I figured out the essential reason behind Lepa being common - one of its phases is the well-known common predecessor of the wing!

Code: Select all

x = 4, y = 5, rule = B2n3/S23-q
2bo$b3o$2b2o$bo$2o!

Well, I say "well-known" because it's in CollisionsSearch. Many of MathAndCode's "new" conduity methuselahs are well-known too.

EDIT: Unrelated, I believe this is the shortest possible c/3 spaceship:

Code: Select all

x = 25, y = 9, rule = B2n3/S23-q
3bo$2bobo7b3o5bo$bo3bo3bob2o3bo3b2o$4b3ob2ob2o3b3o3bo$2o4b2o3bob2o3bob
ob2o$8bo3b3obo3bo2b2o$2bo9bo2b3obo$2o13bobo2b2o$obo!

[ENORMOUS_NAME]

known?

Code: Select all

x = 10, y = 3, rule = B2n3/S23-q
3A5.A$A.A4.3A$3A4.3A!

[400spartans]

EDIT: Unrelated, I believe this is the shortest possible c/3 spaceship:

Code: Select all

spaceship

Shortest possible appears to be this height-7 one:

Code: Select all

x = 51, y = 7, rule = B2n3/S23-q
4bo5b3o7b3o15b3o5bo$3b2o3bo3b2obo3bo3b2o10bob2o3bo3b2o$2bo3b3o3b2ob2o
4bo3bo3bo4b2ob2o3b3o3bo$b2obobo3b2obo3bo4b2o4b2o3bo3bob2o3bobob2o$2o2b
o3bob3o3bo10bo3b2obo3b3obo3bo2b2o$5bob3o2bo15bo2b2o5bo2b3obo$3b2o2bobo
21b2o8bobo2b2o!

[lemon41625]

2c/5 Blinker Puffer

Code: Select all

x = 16, y = 38, rule = B2n3/S23-q
3bo8bo$2bobo6bobo$bo3bo4bo3bo$b2ob2o4b2ob2o$2bo10bo$4bo6bo$5bob2obo$4b
o2b2o2bo$4b8o$3bo8bo$2bobo6bobo$2b3obo2bob3o$2b2o3b2o3b2o2$2b3o6b3o$3b
2o2b2o2b2o$3b4o2b4o$4bo6bo$4b2o4b2o$4b8o$5b2o2b2o2$6b4o$7b2o$6bo2bo$4b
2o4b2o$5b2o2b2o$6bo2bo$2b2o2bo2bo2b2o$5b2o2b2o$4b3o2b3o$5b2o2b2o$5b6o
2$7b2o$2b2o8b2o$2b5o2b5o$o6b2o6bo!

[Hunting]

known?

Code: Select all

x = 10, y = 3, rule = B2n3/S23-q
3A5.A$A.A4.3A$3A4.3A!

Not known, although the SL was known to be common. Nice!

EDIT: Unrelated, I believe this is the shortest possible c/3 spaceship:

Code: Select all

spaceship

Shortest possible appears to be this height-7 one:

Code: Select all

x = 51, y = 7, rule = B2n3/S23-q
4bo5b3o7b3o15b3o5bo$3b2o3bo3b2obo3bo3b2o10bob2o3bo3b2o$2bo3b3o3b2ob2o
4bo3bo3bo4b2ob2o3b3o3bo$b2obobo3b2obo3bo4b2o4b2o3bo3bob2o3bobob2o$2o2b
o3bob3o3bo10bo3b2obo3b3obo3bo2b2o$5bob3o2bo15bo2b2o5bo2b3obo$3b2o2bobo
21b2o8bobo2b2o!

While that's height-8, excellent find indeed! How did you find it? Osrc? Lifesrc?

2c/5 Blinker Puffer

Code: Select all

x = 16, y = 38, rule = B2n3/S23-q
3bo8bo$2bobo6bobo$bo3bo4bo3bo$b2ob2o4b2ob2o$2bo10bo$4bo6bo$5bob2obo$4b
o2b2o2bo$4b8o$3bo8bo$2bobo6bobo$2b3obo2bob3o$2b2o3b2o3b2o2$2b3o6b3o$3b
2o2b2o2b2o$3b4o2b4o$4bo6bo$4b2o4b2o$4b8o$5b2o2b2o2$6b4o$7b2o$6bo2bo$4b
2o4b2o$5b2o2b2o$6bo2bo$2b2o2bo2bo2b2o$5b2o2b2o$4b3o2b3o$5b2o2b2o$5b6o
2$7b2o$2b2o8b2o$2b5o2b5o$o6b2o6bo!

Ah, I guess I will download ikpx2 at some point.

EDIT: Almost certainly known:

Code: Select all

x = 12, y = 26, rule = B2n3/S23-q
5b3o$3b2ob2o$2b2o6bo$b2o4b3o$6bo3bo$2bo4bo2bo$2b3o6bo$2b2o6bo$2b4ob3o$
3b3obo$2b3o$8b2o$2bo3b2ob2o$2b3o3bo$6bo$2bo$2bo6bo2$2o8b2o$b2o6b2o2$2b
o6bo$bobo4bobo$4bo2bo2$2b3o2b3o!