theDragn wrote:Also, theoretically, any object that can be made from glider synthesis can be made from slow salvo glider synthesis or P1 slow salvo glider synthesis. Is there any simple way to find one of these for a cordership?
Sure... well, fairly simple -- but definitely time-consuming! It would be a very interesting project, but I think the final slow salvo would have to contain thousands of gliders, or at least many hundreds.
Here's a possible way to get started: Golly's Patterns/Life/Syntheses/blockish-and-blockic-seeds.rle has a fair variety of one-time glider turners and splitters with different timings. It also shows some examples of how a single glider can hit a constellation of blocks and produce a precisely synchronized set of gliders.
So in this case the first goal could be to make a block constellation that produces this recipe:
Code: Select all
#C 15 gliders -> Cordership
x = 161, y = 169, rule = B3/S23
101bobo10bo$101boo9boo$12bo89bo10boo$13boo$12boo33$27bo$25bobo$26boo$
101bobo$101boo$102bo$$bbobo$3boo$3bo53$110boo$110bobo$110bo$23b3o$25bo
$24bo5$oo$boo$o25b3o$28bo$27bo5$75b3o$75bo$bo74bo$boo$obo$$113b3o$113b
o$114bo3$158b3o$158bo$159bo35$105boo$105bobo$105bo!
Next you'll need a slow-salvo recipe that produces that particular block field, starting from a single block. This will break some new ground, since there aren't many existing examples of this kind of construction. One of the few working samples is built into Golly's Patterns/Life/Signal-Circuitry/constructor-memory-loop.rle. It builds a line of eaters, not a field of blocks, but the general idea is there.
As long as they're spaced a few cells apart from each other, any field of blocks can be cobbled together using recipes from
Paul Chapman's block-move table, plus a few good block splitters -- i.e., slow-salvo recipes that turn one block into two or more. Below is the simplest block splitter, which may not be the best for all purposes -- it has good sideways reach, but you'd end up having to build the block field from one side, and any time one block is right in front of another one, you'd have to construct the frontmost block first.
Code: Select all
#C two slow-salvo gliders split a block into two blocks
x = 18, y = 11, rule = B3/S23
b2o$b2o2$bo$2o$obo3$16b2o$15b2o$17bo!
If you look through the block-move table, you'll find more expensive block splitters that shove one block back to the back of the construction area. That should allow for more straightforward back-to-front incremental constructions.
Of course, block constellations aren't really the most efficient way to build seeds for synchronized gliders -- there are much quicker-to-construct one-time turners made of constellations of beehives, boats, blinkers and so on, as well as blocks.
But any given one-time turner can generally only be slow-salvo-constructed cheaply from one particular direction. It quickly becomes very complicated to string together a series of these with a workable combination of timings, while still making sure that the various slow-salvo constructions don't get in each other's way anywhere. Every time a glider turns 90 degrees, you have to use a whole new set of turners for the next reflection... Eventually this problem might be a good target for a new search engine. Meanwhile, blocks are wonderfully common and wonderfully symmetrical. They can be easily constructed from any direction, so Blockic-constellation constructions are a good way to simplify the search problem.
Once I'm done with the
Hersrch update I'm working on now, I'm planning to cobble together some Python scripts to help out with slow-salvo constructions (unless someone else does it first, of course). One script will accept a slow-salvo recipe in the form of a list of glider lanes, and show the result of the construction. Another will encode an input slow salvo (again, a list of glider lanes) as a data stream for a one-arm Geminoid replicator unit. The output will be a salvo of gliders on a single lane, which will move a Geminoid construction elbow as necessary to output the target slow salvo. And a third script will take a block constellation as input and automatically "compile" it into a slow-salvo recipe and/or a Geminoid construction recipe.
-------------------------------------
A really surprising result from the last few years is that if you start with a couple of blocks and send gliders at one of them _on a single lane_, synchronized in pairs, that's enough to incrementally construct anything that's glider-constructible. Might even be able to start with just one block, not two... but a good bit of development work will have to be done to make that into a practical construction method.