I thought of an idea for searching for spaceships. The idea is to set the cells behind the forward movement mechanism to random states and test which work and which don't. If certain cells being on always or almost always result in the forward movement mechanism breaking before at least one repetition, then the search program can start off assuming that they're off. If certain cells always end up on after the intended period if the forward movement mechanism survives, then the program can assume that they're on. Thus, the program starts off knowing which cells are probably on or probably off without using as much computational effort, thus guiding the program so it doesn't spend time on paths that are unlikely to work. A good example is the switch engine. Here is a list of the objects shortly behind the switch engine every 48 generations:
0 generations: Nothing
48 generations: A 23-cell cluster
96 generations: The same 23-cell cluster one one side and a block on the other side
144 generations: The same 23-cell cluster approaching a block on one one side and a block on the other side
192 generations: The same cluster approaching a block on one one side and a block on the other side
240 generations: The same cluster approaching a block on one one side and a block on the other side
288 generations: The same cluster approaching a block on one one side and a block on the other side
336 generations: The same cluster approaching a block on one one side and an eight-cell B-like forward movement mechanism with trailing junk (eleven cells) on the other side
384 generations: The same cluster approaching a block on one one side and a block on the other side
432 generations: The same cluster approaching a traffic on one one side and a blinker and beehive on the other side
480 generations: The same cluster approaching a blinker and beehive on one one side and a boat and block on the other side
528 generations: The same cluster approaching a boat and block on one one side and a block on the other side
576 generations: The same cluster approaching a block on one one side and nothing close behind on the other side
624 generations: The same cluster on one one side and a block on the other side
672 generations: The same cluster approaching a block on one one side and a block on the other side
768 generations: The same cluster approaching a block on one one side and a block and honey farm predecessor on the other side
816 generations: The same cluster approaching some junk on one one side and a long boat on the other side
864 generations: The same cluster approaching a block on one one side and a blinker on the other side
918 generations: The same cluster approaching a blinker on one one side and a block on the other side
960 generations: A somewhat modified cluster approaching some junk on one one side and a block on the other side
1008 generations: The same cluster approaching a block on one one side and some junk on the other side
1056 generations: The same cluster approaching a blinker on one one side and a block on the other side
1104 generations: The same cluster approaching a block on one one side and a honey farm predecessor on the other side
1152 generations: The same cluster approaching a honey farm on one one side and a block on the other side
1200 generations: The switch engine has been destroyed.
The data shows that while the cluster does not always have to appear in its exact form in order for the switch engine to survive (as shown in generations 0 and 960), it appears the vast majority of the time and therefore would likely occur in any stabilization of a switch engine. The same is true for the blocks; they do not have to appear in order for the switch engine to survive for 48 more generations, but they do most of the time. Also, when the switch engine was destroyed, the 23-cell cluster and two block debris behind the switch engine had not occurred for over 300 generations. While this is not conclusive in and of itself, other runs with random cell behind the switch engine reinforce this point. (I omitted one run where the switch engine was destroyed by a glider, two runs that ended in the same way as a previous run, one run that ended in a GPSE, eight runs that ended in a BLSE, and two runs where the switch engine was destroyed before generation 50.)
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$13bo2bo5b2ob2o$15b6ob5o$13bob2o8bob2o$14b2ob2ob6o$14bo2bo2bobobob2o$14bo2bob3o5b2o$14b2o2b2o3b2ob3o$13b3ob3ob4ob2o$14bo5b4ob2o$13b2o3b2obo4b2o$16bobo2b2o3b3o$13bobobobo2bobobobo$13bob2o3b6ob2o$13bob4ob9o$13bo2bo3bobo4b2o$14b2ob2o2bob5o!
The switch engine initially develops the stable 23-cell cluster and two block trail and is stable then. It loses that trail around generation 300, never gets it back, and dies about 250 generations later.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$14bobo4b4obo$14bo2b2o2bo5b2o$16bob3obo2b4o$14b3obob5o2b2o$13b4ob2o3bo4bo$14bo2bo3b2ob4o$13bo4b4obo2bobo$14bobob2ob2obobobo$13b2ob7o2b2obo$14b2obo2bo2bo2bo$14bo2bob2obo3bobo$15bo2bo2b2o2b3o$13bo2bob3o5b2o$15bobobo2b2obo$15bob2o6b4o$13bo5b2o2bo3bo!
The switch engine develops the 23-cell cluster and two block trail around generation 150 then gradually loses it between generations 650 and 1000 but then gradually regains it between generations 1100 and 1400. A beehive instead of a block at generation 1680 causes the switch engine to lose its stable trail again, and the debris kills the switch engine around generation 1850.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$14bo2b3obo2bo2bo$13bobob2o2bo2bo2b2o$14bo2bo3b2ob2o2bo$14b2o2b2o3b6o$15b3o2bo4bobo$13bo2bob2o2bo2bob2o$13bo2bob5o3bobo$13b5ob3o3bobo$15b2o2bo2bob4o$13bo2b3o4b3ob2o$13bob5obob6o$14bob3o2bobo2bo$13b4o7bobobo$13b4ob2ob4o2bo$13b8o3bo3bo$16bobobo2b3obo!
The switch engine never gains the stable trail and is destroyed around generation 150.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$14bo5b2o2bo2b2o$13b3obo2b2ob3o2bo$13b2ob4o3b2o2b2o$13bo4bobobob2obo$15bo2bobo3b2obo$14b2obo2bo2bob3o$14b3ob2o2bo3b3o$13bo2bo2bobo2bobo$13bobobo2b3ob2o2bo$15b2o2b3o3b2o$13bo2bo2bob7o$13b2obob2o4b3o$13b7obob2ob3o$13b4obo3b4o$14b2ob3obo3bobo$13b3ob2ob2ob5o!
The switch engine partially develops the stable trail early on but never completely develops it and is destroyed about generation 400.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$13b5obobo2b2ob2o$13bo4bob4o3bo$17bo2bo2bobobo$13bo2bobob3ob3obo$13bobob4o2bobo$13bobo3b2obo2bo$19b6o2b2o$13b2ob3o3b2obo2bo$18b6ob2o$17bob2obo5bo$14b2obobo4b4o$13b2obob2o4b5o$13bo3b3o2bob2o2bo$13bo2bobob2ob3ob2o$13b2obo4b2ob2o2bo$13bo3bo9bo!
The switch engine develops the three-cluster stable trail early on but starts to lose it after generation 200 and never has a three-cluster stable trail again except twice around generation 800. It dies around generation 950.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$13b2o2bobo2bo4bo$14bobob3obo3b2o$15bo4bo2b2ob2o$13bob3ob2o2bob4o$13b2obo2bob3o3bo$16bo2b5o2bobo$17bo2b2obobob2o$14b3obobo3b3obo$14b4o2b3ob3obo$15b2o2bobo2b2o2bo$14bobobo3b3o2b2o$13b2ob2obo2b2o3b2o$13b2o2bobob3ob3o$14b4o4b3obo$13b4obob2obo2bo$17bo4bo2b4o!
The switch engine is followed by the twenty-three cell cluster at every multiple of 48 generations except two of the last three before the switch engine dies (and of course at generation 0), which is around generation 2,200. However, this is not followed by two blocks at most multiples of 48 generations.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$13b3o2bo5bobo$13b4obob4ob4o$13b2obo4b4obobo$15b6o2bob4o$13b4o3bob2ob3o$17bo2bobo3bobo$15bob2o4bo3bo$13b4ob2o4b2ob2o$18b3o2b4o$14b2o2b4obobobo$14bo2b2o2bo5b2o$13b2o2bo3b3o2b2o$13b3o3b3obo2bo$14b2o3bo2b6o$14bobo2bobo5b2o$16bo4b3ob3o!
This doesn't develop the stable three-cluster trail and dies around generation 100.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$15bo2bo3b3o3bo$13b3ob2ob2o$13bobo2bo7bobo$14bo6bobo3b2o$13b2o2b3ob2o3bo$14bobo2b2obo2b4o$15bo2b3o5b3o$14bob7obo3bo$15b3ob3o3b4o$14b6o2b3o$15bobo4b6o$16b2o5b2o2b2o$13b2obo3bo2bo2bo$13bob2o3b3o4b2o$17b2obobobob2o$20b2ob2o2bo!
This develops a stable three-cluster trail by generation 150, loses it around generation 400, and dies around generation 500.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$16bob2o2bo2b2obo$13b2o2bob2o2bo3bo$13bo3b2ob2obo2bo$15b4o2bo2bobobo$13b4o4b2o2bobo$13b3o5b4o2bo$13bobo3bobo3bobo$13bob3o2b4o2bo$13b2o2b4o2bo4bo$13bob2ob2obob5o$13b7ob2o2b2o$19bobo2bo$13bob2o3bobo3b2o$13b2o6b2ob5o$13bobo2bo2b2o5bo$16bob6obobo!
This doesn't develop the stable trail and dies around generation 100.
Code: Select all
x = 29, y = 24, rule = B3/S23
bobo$o$bo2bo$3b3o5$14bob2obob2obo$14b3o2bobo3bob2o$15bobob2ob2o$13bob2o2bo5b4o$13b2o2b3ob2o3b3o$14bo2b4o2b4obo$15b2o2b5o3b2o$14b2o4b5o2b2o$13bo2b4o2bob2obo$17b3o4b2obo$13b3ob3obo2b2o$13bob2o3bo2bo2b3o$14bo3bo5bo2b2o$14bo4bobob4obo$13bob2o5b5o$14b2obobob8o!
This doesn't develop the stable three-cluster trail. At generation 288, its 23-cell cluster can be seen interacting with some junk, and the resulting reaction kills the switch engine about thirty generations later.
The data shows that having two blocks behind the 23-cell cluster tends to increase switch engine stability. There is one exception, the sixth RLE, where the switch engine survives for over 2,000 generations without having two blocks behind its 23-cell cluster at most multiples of 48, but this means that most spaceship-searching programs would spend most of their time on switch engines not followed by two blocks even though most of the hope for stabilizing a switch engine would come there. Therefore, my method would be better in this circumstance if one only cared about finding a spaceship and not necessarily knowing that one had found all spaceships in a given bounding region.
Here are the advantages and disadvantages of my idea.
Advantages:
- It does not waste time looking for less likely partials, so it would be quicker.
- It is theoretically (because it feeds its results to another program that probably isn't compatible) compatible with higher periods with the same simplified speed.
- The initial part does not take exponentially more time as a function of the period.
Disadvantages:
- Too few runs of random soup will compromise the ability to make accurate assessments of the probability (although this will probably only apply to the first few generations, so this should not be a major problem unless the partial dies before two periods, in which case it's probably not a good partial anyway).
- It is not exhaustive.
- It is possible to miss some spaceships (although the time not used finding those spaceships could theoretically be used finding more spaceships in other speeds).
- It is possible for multiple computers to pursue the same partial that turns out to be a dead end.
- No one has coded it yet.
By the way, this changes speed four times.
Code: Select all
x = 7, y = 6, rule = B3/S23
4b3o$4bobo$3bo2bo$3bobo$3b3o$3o!
I am tentatively considering myself back.