ConwayLife.com - A community for Conway's Game of Life and related cellular automata
Home  •  LifeWiki  •  Forums  •  Download Golly

Enumerating Three-Glider Collisions

For scripts to aid with computation or simulation in cellular automata.

Enumerating Three-Glider Collisions

Postby dvgrn » April 23rd, 2017, 8:40 pm

From the "Implications of a Three-Glider Switch Engine" thread:
dvgrn wrote:Someone should start a new thread for best-practices methods of filtering as-near-as-possible all distinct 3-glider collisions that produce small constellations. I used chris_c's suggestions from gencols: techniques -- thanks, chris_c!

AbhpzTa's discovery of a three-glider SE recipe is something of a wake-up call here. That recipe could have been found any time in the last forty years by enumerating all possible collisions of a glider with a 2-glider [traffic light|block|nothing] recipe.

Given that surprising fact, how likely is it that this new switch-engine recipe is the last unknown three-glider constructible object? How do we know there isn't a clean three-glider recipe for a snake out there somewhere, for example? Or pick your favorite object that we think needs more than three gliders to construct.

Switch engines were a weird case
New super-cheap still life recipes are not terribly likely, of course. The search space has been combed over fairly thoroughly by now, by several people... it's just that no one doing three-glider searches was specifically looking for switch engines, so presumably they got thrown out with all the other big messy explosions.

-- Well, simsim314 found a three-glider collision that produces a switch engine, a few years back, but that search wouldn't have found AbhpzTa's recipe either because clean switch engines self-destruct before too many cycles.

Constellations
There's also the problem of generating arbitrary small constellations as cheaply as possible, with fair confidence that the cheapest recipe has been found. An incredible number of two- and three-object constellations can be constructed with just three gliders, it's a huge search space. But so far, unless someone has a pre-built gencols collisions file that they haven't mentioned, pretty much every such problem has been solved by a separate search.

An Exact Count
The problem of enumerating all distinct three-glider collisions seems just about within reach these days. One thing we might be able to come up with is a precise total number of distinct output patterns excluding gliders, produced by configurations of three gliders in which all three participate in a collision.

If we don't exclude gliders the number of distinct outputs is unlimited, thanks to useless kickbacks on the 2-glider mess, TL+glider, and the three B-heptomino recipes. For example, the following infinite series will have distinct hashes (until the hash-generating algorithm fails and there's a collision, but that's a mighty long way out...!)

x = 547, y = 120, rule = B3/S23
354bo$355b2o$177bo176b2o$178b2o$o176b2o$b2o$2o66$540bo2bo2bo36$129bo
176bo176bo$128bo176bo176bo$128b3o174b3o174b3o7$126bo176bo176bo$125b2o
175b2o175b2o$125bobo174bobo174bobo!

The hard part is that kickbacks do have to be allowed sometimes, when the kicked-back glider strikes an active or just-settled pattern. Once the kicked-back glider is striking the exact same settled pattern as another pattern's kicked-back glider, I think it shouldn't count as distinct. Seems like it will be pretty hard to get that count exactly right, but that's only a problem with five of the 71 collisions -- could leave those for last.

Thinking about moving the search tree up to four gliders, though, the problem is even worse. Kickback reactions that didn't count as distinct when the search stopped at three gliders, would suddenly count (by producing a different output pattern) when a fourth glider is added.

Collisions and Outputs
The full list of outputs, mostly copied from the 2-glider-collisions stamp collection, is

nothing, blinker, block, glider, boat, beehive, loaf, eater, pond, bi-block, loaf+blinker, loaf+blinker+tub+block (misc), half-blockade (misc), four skewed blocks (misc), traffic light, honeyfarm, B-heptomino, pi, lumps of muck, teardrop, interchange, traffic light+glider, octomino, 2-glider mess.

The great majority of the 71 collisions stabilize within a few dozen ticks. Only one of the "nothing" syntheses takes anywhere close to 100 ticks, for example. Even that is easily within reach of exhaustive enumeration of all possible third gliders.

Enumeration
I'd like to have an enumeration method with at least a little common sense built in -- something along the lines of gencols, tracking the 2-glider collision tick by tick and placing gliders in every possible position where they would interact with the collision for the first time at tick #T.

Really it might be simpler to use plain brute force -- place every glider in every orientation that could possibly touch the collision reaction. Run each one, and then throw away cases where the third glider is totally unaffected by the collision reaction (and vice versa).

Tangent on Heisenburps
If we're trying to get a count of all distinct 3-glider collisions, it's not sufficient to run the pattern and throw out cases where the added third glider is undamaged. There will be the occasional Heisenburp, like these four that showed up in 2003 from investigating just one orientation of B-heptomino:

x = 306, y = 46, rule = B3/S23
102bobo$103b2o$103bo$201bobo$2bo199b2o$obo199bo$b2o16$303bo$301bobo$
302b2o19$3bo99bo99bo99bo$2b3o97b3o97b3o97b3o$b2o2bo95b2o2bo95b2o2bo95b
2o2bo!

-- It would slow things down quite a bit to have to track the third glider through every tick, to see if it ever has a temporary Heisenburp effect that isn't represented in a changed final pattern, I wonder if it would make sense to build a custom multistate Golly rule that changes a glider's color if it ever participates in a Heisenburp?

Handling Different Kinds of Nothing
Along the same lines as those no-effect Heisenburps, it will be good to have a count not just of all the distinct patterns that can result from three-glider collisions, but also all the collisions themselves, even though many of them produce the same final results. A next step might be to use the resulting collision list to try out every possible edgy 3G spark pattern against various still lifes, and see how many new converters turn up.

If we're really trying to get a count of all the distinct three-glider collision reactions, as opposed to distinct outputs, a subtler problem would be Heisenburps that have only a temporary effect -- changing the shape of a dying spark that does something new but then dies out anyway. Theoretically this could matter if we extended the search tree and hit the changed spark with a fourth glider... but in practice, nobody's going to be trying to count four-glider collisions any time soon. And relatively few useful constructions would come out of reactions like this, because there's an extra output glider that has to be disposed of.

Lists of Hashes
It seems like a good place to start would be to make an official list of the 71 2-glider collisions, each at the position where the gliders will interact for the first time on the next tick. Maybe order them by time to stability. For each collision except for the glider-producing ones, it's not too hard for a search program to find all distinct locations/orientations of a third glider that will interact in some way with that collision. If the search is done with a couple of different independent methods and the count agrees, that will be a good sign.

Each initial pattern of three gliders can be assigned an (extended) apgcode, and a hash can be recorded of the initial canonical orientation and also of its eventual stabilized output pattern, minus any gliders. At least one infinite-growth pattern will show up, so I guess that and any other unknown ones can best be handled as special cases.

To determine a final count of three-glider collisions we'll just have to compare the 71 lists of initial hashes and remove any duplicates. The only potential duplicates will be between cases where the third glider interacts immediately, at the same tick as the first two.
dvgrn
Moderator
 
Posts: 3858
Joined: May 17th, 2009, 11:00 pm
Location: Madison, WI

Re: Enumerating Three-Glider Collisions

Postby Extrementhusiast » April 23rd, 2017, 11:02 pm

dvgrn wrote:Really it might be simpler to use plain brute force -- place every glider in every orientation that could possibly touch the collision reaction. Run each one, and then throw away cases where the third glider is totally unaffected by the collision reaction (and vice versa).

I've already been doing this for a few of them as part of my work on syntheses, as it's useful for slightly modifying edgy subpatterns that appear within two-glider collisions.

dvgrn wrote:-- It would slow things down quite a bit to have to track the third glider through every tick, to see if it ever has a temporary Heisenburp effect that isn't represented in a changed final pattern, I wonder if it would make sense to build a custom multistate Golly rule that changes a glider's color if it ever participates in a Heisenburp?

I've already done something similar: a rule that tracks if two differently-colored patterns interact:
@RULE objtracklife2

@TABLE

n_states:5
neighborhood:Moore
symmetries:permute

# all states
var Aa={0,1,2,3,4}
var Ab={Aa}
var Ac={Aa}
var Ad={Aa}
var Ae={Aa}
var Af={Aa}
var Ag={Aa}
var Ah={Aa}

# live states
var La={1,2,3}
var Lb={La}
var Lc={La}
var Ld={La}
var Le={La}
var Lf={La}
var Lg={La}
var Lh={La}

# dead states
var Da={0,4}
var Db={Da}
var Dc={Da}
var Dd={Da}
var De={Da}
var Df={Da}
var Dg={Da}
var Dh={Da}


# off in both universes
# on in both universes (pre-interaction)
# on in only current universe (pre-interaction)
# on in both universes (post-interaction)
# on in only current universe (post-interaction)
# on in only alternate universe
# history in current universe; off in alternate universe
# history in current universe; on in alternate universe


0,Da,Db,Dc,Dd,De,La,La,La,La
Da,Db,Dc,Dd,De,Df,La,Lb,Lc,3

La,Da,Db,Dc,Dd,De,Df,La,La,La
La,Da,Db,Dc,Dd,De,La,La,La,La
La,Da,Db,Dc,Dd,De,Aa,Lb,Lc,3
3,Aa,Ab,Ac,Ad,Ae,Af,Ag,Ah,4
La,Aa,Ab,Ac,Ad,Ae,Af,Ag,Ah,0

0,Aa,Ab,Ac,Ad,1,1,1,2,4
0,Aa,Ab,Ac,Ad,1,2,2,2,4

@COLORS

1 255   0   0
2   0 255   0
3 255 255 255
4 102 102 102

@ICONS

circles

One then just needs to check for cells of at least state 3, which is easily done with another rule: every generation, reduce all non-empty cellstates by one (a bit like //256 in reverse).

(However, I'm planning on making objtracklife3, featuring a three-layered simulation of A, B, and A+B, as soon as I can figure out the details within the damn transitions!)
I Like My Heisenburps! (and others)
User avatar
Extrementhusiast
 
Posts: 1636
Joined: June 16th, 2009, 11:24 pm
Location: USA

Re: Enumerating Three-Glider Collisions

Postby Scorbie » April 23rd, 2017, 11:49 pm

Extrementhusiast wrote:
dvgrn wrote:-- It would slow things down quite a bit to have to track the third glider through every tick, to see if it ever has a temporary Heisenburp effect that isn't represented in a changed final pattern, I wonder if it would make sense to build a custom multistate Golly rule that changes a glider's color if it ever participates in a Heisenburp?

I've already done something similar: a rule that tracks if two different patterns interact...
Why not just run the pattern until stabilization (or the until the generation of stabilization of the two-glider collision) And see if the end product is merely the sum of the two patterns, the two-glider collision stabilization and the third glider?
Best wishes to you, Scorbie
User avatar
Scorbie
 
Posts: 1322
Joined: December 7th, 2013, 1:05 am

Re: Enumerating Three-Glider Collisions

Postby dvgrn » April 24th, 2017, 8:15 am

Scorbie wrote:Why not just run the pattern until stabilization (or the until the generation of stabilization of the two-glider collision) And see if the end product is merely the sum of the two patterns, the two-glider collision stabilization and the third glider?

The possibility of zero-effect Heisenburps makes that not quite good enough. We could end up with a passing glider encouraging a huge and useful spark, for example. The spark might very well die out in the end, producing an identical output as if no Heisenburp had happened.

It looks like a regular no-interaction, and is in danger of getting discarded if we only use the run-to-stabilization test. But that case needs to be counted as a real three-glider collision, and it's not just a technicality -- the spark might turn out to be uniquely useful in some synthesis or other, for all we know.

In practice that's not going to happen much, since Heisenburps by definition always have an extra output glider that will probably need to be disposed of, so there's a built-in inefficiency. Really the main reason for noticing these is that if you don't, the statistics on the total number of 3-glider collisions will be wrong (horrors!)
dvgrn
Moderator
 
Posts: 3858
Joined: May 17th, 2009, 11:00 pm
Location: Madison, WI

Re: Enumerating Three-Glider Collisions

Postby Scorbie » April 24th, 2017, 12:44 pm

dvgrn wrote:It looks like a regular no-interaction, and is in danger of getting discarded if we only use the run-to-stabilization test. But that case needs to be counted as a real three-glider collision, and it's not just a technicality -- the spark might turn out to be uniquely useful in some synthesis or other, for all we know.

In practice that's not going to happen much, since Heisenburps by definition always have an extra output glider that will probably need to be disposed of, so there's a built-in inefficiency. Really the main reason for noticing these is that if you don't, the statistics on the total number of 3-glider collisions will be wrong (horrors!)
Ah, I see, thanks :) Having a similar idea for ptbsearch, I decided (in my vaporware blueprint) to discard those cases...
Best wishes to you, Scorbie
User avatar
Scorbie
 
Posts: 1322
Joined: December 7th, 2013, 1:05 am

Re: Enumerating Three-Glider Collisions

Postby dvgrn » April 24th, 2017, 1:58 pm

dvgrn wrote:It seems like a good place to start would be to make an official list of the 71 2-glider collisions, each at the position where the gliders will interact for the first time on the next tick.

On second thought, it seems like a better idea to start N ticks back from the first interaction. When we drop in glider #3, we have to have some way to verify that the new glider would not have interacted with either of the existing gliders before they collide with each other.

(If this happens, we'll get unnecessary duplication -- the collision usually becomes a different collision entirely, of a type that will be enumerated elsewhere.)

The only duplication that needs to be checked for will be in the fairly limited number of cases where the three gliders all start interacting on the same tick. If any two gliders A and B start interacting first, then that collision is the primary collision, and the 3-glider recipe can be enumerated unambiguously as "glider collision #{0..70} plus {NE|SE|SW|NW} glider on lane L, delay of T ticks".

It seems like an interesting subproblem to generate all of these simultaneous-collision cases, and remove the duplicates -- probably using a dictionary of apgcodes, to automatically choose a canonical orientation.

Once the duplicates are removed, a delayed glider can be added in every possible way to each of the 71 collisions. That will be 71 separate searches, with no possibility of duplication with any other search. Or am I missing something important here?

... It should be fairly easy to produce four graphs for each of the 71 collisions, showing the possible {NE|SE|SW|NW} lanes in one dimension, and the allowable values of T (delay times) on each lane that produce actual collisions -- instead of trivial flyby behavior, or duplication due to collision with an already-settled part of the pattern. Maybe separate colors for small constellations and for the occasional Heisenburp reactions.
dvgrn
Moderator
 
Posts: 3858
Joined: May 17th, 2009, 11:00 pm
Location: Madison, WI

Re: Enumerating Three-Glider Collisions

Postby _zM » April 25th, 2017, 2:27 pm

dvgrn wrote:Tangent on Heisenburps
If we're trying to get a count of all distinct 3-glider collisions, it's not sufficient to run the pattern and throw out cases where the added third glider is undamaged. There will be the occasional Heisenburp, like these four that showed up in 2003 from investigating just one orientation of B-heptomino:

x = 306, y = 46, rule = B3/S23
102bobo$103b2o$103bo$201bobo$2bo199b2o$obo199bo$b2o16$303bo$301bobo$
302b2o19$3bo99bo99bo99bo$2b3o97b3o97b3o97b3o$b2o2bo95b2o2bo95b2o2bo95b
2o2bo!

-- It would slow things down quite a bit to have to track the third glider through every tick, to see if it ever has a temporary Heisenburp effect that isn't represented in a changed final pattern, I wonder if it would make sense to build a custom multistate Golly rule that changes a glider's color if it ever participates in a Heisenburp?



So I tried making that rule you mentioned, and it kind of works:
@RULE heisenbork

@TABLE
n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var a = {0,1,2}
var b = a
var c = a
var d = a
var e = a
var f = a
var g = a
var h = a
var i = a

var j = {1,2}
var k = j
var l = j
var m = j

0,1,1,1,0,0,0,0,0,1 #B3a
0,0,1,1,1,0,0,0,0,1 #B3i
0,1,1,0,1,0,0,0,0,1 #B3n
0,1,0,1,1,0,0,0,0,1 #B3j

1,1,1,0,0,0,0,0,0,1 #S2a
1,1,0,1,0,0,0,0,0,1 #S2e
1,1,0,1,1,0,0,0,0,1 #S3j
1,1,1,0,1,0,0,0,0,1 #S3n
1,1,1,0,0,1,0,0,0,1 #S3r

j,k,l,0,0,0,0,0,0,2 #S2a
j,k,0,l,0,0,0,0,0,2 #S2e
j,k,0,0,l,0,0,0,0,2 #S2k
j,k,0,0,0,l,0,0,0,2 #S2i
j,0,k,0,0,0,l,0,0,2 #S2n
j,0,k,0,l,0,0,0,0,2 #S2c

a,j,0,k,l,0,0,0,0,2 #3j
a,j,k,0,l,0,0,0,0,2 #3n
a,j,k,0,0,l,0,0,0,2 #3r
a,0,j,0,k,0,l,0,0,2 #3c
a,j,0,k,0,l,0,0,0,2 #3e
a,j,0,k,0,0,l,0,0,2 #3k
a,j,k,l,0,0,0,0,0,2 #3a
a,0,j,k,l,0,0,0,0,2 #3i
a,0,j,k,0,0,l,0,0,2 #3q
a,j,0,0,k,0,l,0,0,2 #3y

a,b,c,d,e,f,g,h,i,0


Of the four heisenburps shown above, this rule detects two (by turning the glider from state 1 to state 2). I don't know if this is any useful, but...
Life: Because wires and loops are just too boring.
User avatar
_zM
 
Posts: 129
Joined: June 26th, 2016, 3:07 pm

Re: Enumerating Three-Glider Collisions

Postby Rhombic » April 26th, 2017, 9:26 am

_zM wrote:
dvgrn wrote:Tangent on Heisenburps
If we're trying to get a count of all distinct 3-glider collisions, it's not sufficient to run the pattern and throw out cases where the added third glider is undamaged. There will be the occasional Heisenburp, like these four that showed up in 2003 from investigating just one orientation of B-heptomino:

x = 306, y = 46, rule = B3/S23
102bobo$103b2o$103bo$201bobo$2bo199b2o$obo199bo$b2o16$303bo$301bobo$
302b2o19$3bo99bo99bo99bo$2b3o97b3o97b3o97b3o$b2o2bo95b2o2bo95b2o2bo95b
2o2bo!

-- It would slow things down quite a bit to have to track the third glider through every tick, to see if it ever has a temporary Heisenburp effect that isn't represented in a changed final pattern, I wonder if it would make sense to build a custom multistate Golly rule that changes a glider's color if it ever participates in a Heisenburp?



So I tried making that rule you mentioned, and it kind of works:
@RULE heisenbork

@TABLE
n_states:3
neighborhood:Moore
symmetries:rotate4reflect

var a = {0,1,2}
var b = a
var c = a
var d = a
var e = a
var f = a
var g = a
var h = a
var i = a

var j = {1,2}
var k = j
var l = j
var m = j

0,1,1,1,0,0,0,0,0,1 #B3a
0,0,1,1,1,0,0,0,0,1 #B3i
0,1,1,0,1,0,0,0,0,1 #B3n
0,1,0,1,1,0,0,0,0,1 #B3j

1,1,1,0,0,0,0,0,0,1 #S2a
1,1,0,1,0,0,0,0,0,1 #S2e
1,1,0,1,1,0,0,0,0,1 #S3j
1,1,1,0,1,0,0,0,0,1 #S3n
1,1,1,0,0,1,0,0,0,1 #S3r

j,k,l,0,0,0,0,0,0,2 #S2a
j,k,0,l,0,0,0,0,0,2 #S2e
j,k,0,0,l,0,0,0,0,2 #S2k
j,k,0,0,0,l,0,0,0,2 #S2i
j,0,k,0,0,0,l,0,0,2 #S2n
j,0,k,0,l,0,0,0,0,2 #S2c

a,j,0,k,l,0,0,0,0,2 #3j
a,j,k,0,l,0,0,0,0,2 #3n
a,j,k,0,0,l,0,0,0,2 #3r
a,0,j,0,k,0,l,0,0,2 #3c
a,j,0,k,0,l,0,0,0,2 #3e
a,j,0,k,0,0,l,0,0,2 #3k
a,j,k,l,0,0,0,0,0,2 #3a
a,0,j,k,l,0,0,0,0,2 #3i
a,0,j,k,0,0,l,0,0,2 #3q
a,j,0,0,k,0,l,0,0,2 #3y

a,b,c,d,e,f,g,h,i,0


Of the four heisenburps shown above, this rule detects two (by turning the glider from state 1 to state 2). I don't know if this is any useful, but...


It should make detection of Heisenburps trivial with a very simple script. The question is whether the Heisenburps themselves are useful and the answer should be "generally yes, especially for stable ash (i.e. stable glider detectors)". However, there's that - most Heisenburps will involve a Heisenburp chaotic explosion from a constellation or, in fact, mainly Heisenburps with non-stable patterns. The latter would need specific design to be incorporated into any kind of circuitry and, on top of that, synchronising a glider - if it is, say, p120 Herschel interactions, the gliders can only transmit information at a maximum of 120 ticks per bit. How useful is this? Just now, not that useful. But Boole never imagined his concepts ending up being so amazingly important either.

The main problem is, with the current state-of-art circuitry, at most there will be four or five Heisenburps that are actually worth discovering (without having to design massive circuits to use them in a totally different way). Even then, these will most certainly be edge-shooters and still, it is highly unlikely for there to be a useful Heisenburp associated.

But the script is trivial nonetheless (check that pattern evolution is different from the same without the glider, then check glider has changed colour to avoid trivial solutions and check that it is in the same position as an unhindered evolution).
User avatar
Rhombic
 
Posts: 722
Joined: June 1st, 2013, 5:41 pm

Re: Enumerating Three-Glider Collisions

Postby dvgrn » May 27th, 2017, 3:31 pm

Extrementhusiast wrote:I've already done something similar: a rule that tracks if two differently-colored patterns interact:
@RULE objtracklife2...

That seems to work fine for any possible Heisenburp -- at least, it passes the test for all four samples that I posted:

x = 307, y = 166, rule = objtracklife2
102.B.B$103.2B$103.B$201.B.B$2.B199.2B$B.B199.B$.2B16$303.B$301.B.B$
302.2B19$3.A99.A99.A99.A$2.3A97.3A97.3A97.3A$.2A2.A95.2A2.A95.2A2.A
95.2A2.A75$103.A.A$104.2A$104.A$202.A.A$3.A199.2A$.A.A199.A$2.2A16$
304.A$302.A.A$303.2A19$4.B99.B99.B99.B$3.3B97.3B97.3B97.3B$2.2B2.B95.
2B2.B95.2B2.B95.2B2.B!

Extrementhusiast wrote:One then just needs to check for cells of at least state 3, which is easily done with another rule: every generation, reduce all non-empty cellstates by one (a bit like //256 in reverse).

Here's the cleanup rule boiled down to about as simple as I can make it. If the universe isn't empty after the combined state-1 and state-2 pattern runs for LONG_ENOUGH in objtrack2, and then one tick in objtrackcleanup, then the two subpatterns interacted:

@RULE objtrackcleanup

@TABLE
n_states:5
neighborhood:oneDimensional
symmetries:none

var a = {0,1,2,3,4}
var b = a
var c = {3,4}
var d = {1,2}
c,a,b,3
d,a,b,0

Extrementhusiast wrote:(However, I'm planning on making objtracklife3, featuring a three-layered simulation of A, B, and A+B, as soon as I can figure out the details within the damn transitions!)

Wasn't that already done a few years ago? ... ah, I guess that was just two superimposed layers, not three. For three layers I'd probably have to give up and write a script to generate the rule -- sorting out all the transitions by hand would be too much of a pain.
dvgrn
Moderator
 
Posts: 3858
Joined: May 17th, 2009, 11:00 pm
Location: Madison, WI

Re: Enumerating Three-Glider Collisions

Postby Extrementhusiast » May 29th, 2017, 6:37 pm

dvgrn wrote:
Extrementhusiast wrote:(However, I'm planning on making objtracklife3, featuring a three-layered simulation of A, B, and A+B, as soon as I can figure out the details within the damn transitions!)

Wasn't that already done a few years ago? ... ah, I guess that was just two superimposed layers, not three. For three layers I'd probably have to give up and write a script to generate the rule -- sorting out all the transitions by hand would be too much of a pain.


I did so without using such a script (although using other software, in this case Mathematica, to generate what combinations made what):
@RULE deeperlife

@TABLE

n_states:8
neighborhood:Moore
symmetries:permute

# all states
var a={0,1,2,3,4,5,6,7}
var b={a}
var c={a}
var d={a}
var e={a}
var f={a}
var g={a}
var h={a}
var i={a}

# states with red
var Ra={4,5,6,7}
var Rb={Ra}
var Rc={Ra}
var Rd={Ra}
var Re={Ra}
var Rf={Ra}
var Rg={Ra}
var Rh={Ra}
var Ri={Ra}

# states without red
var ra={0,1,2,3}
var rb={ra}
var rc={ra}
var rd={ra}
var re={ra}
var rf={ra}
var rg={ra}
var rh={ra}
var ri={ra}

# states with green
var Ga={2,3,6,7}
var Gb={Ga}
var Gc={Ga}
var Gd={Ga}
var Ge={Ga}
var Gf={Ga}
var Gg={Ga}
var Gh={Ga}
var Gi={Ga}

# states without green
var ga={0,1,4,5}
var gb={ga}
var gc={ga}
var gd={ga}
var ge={ga}
var gf={ga}
var gg={ga}
var gh={ga}
var gi={ga}

# states with blue
var Ba={1,3,5,7}
var Bb={Ba}
var Bc={Ba}
var Bd={Ba}
var Be={Ba}
var Bf={Ba}
var Bg={Ba}
var Bh={Ba}
var Bi={Ba}

# states without blue
var ba={0,2,4,6}
var bb={ba}
var bc={ba}
var bd={ba}
var be={ba}
var bf={ba}
var bg={ba}
var bh={ba}
var bi={ba}

# states with red and with green
var RGa={6,7}
var RGb={RGa}
var RGc={RGa}
var RGd={RGa}
var RGe={RGa}
var RGf={RGa}
var RGg={RGa}
var RGh={RGa}
var RGi={RGa}

# states with red and without green
var Rga={4,5}
var Rgb={Rga}
var Rgc={Rga}
var Rgd={Rga}
var Rge={Rga}
var Rgf={Rga}
var Rgg={Rga}
var Rgh={Rga}
var Rgi={Rga}

# states without red and with green
var rGa={2,3}
var rGb={rGa}
var rGc={rGa}
var rGd={rGa}
var rGe={rGa}
var rGf={rGa}
var rGg={rGa}
var rGh={rGa}
var rGi={rGa}

# states without red and without green
var rga={0,1}
var rgb={rga}
var rgc={rga}
var rgd={rga}
var rge={rga}
var rgf={rga}
var rgg={rga}
var rgh={rga}
var rgi={rga}

# states with red and with blue
var RBa={5,7}
var RBb={RBa}
var RBc={RBa}
var RBd={RBa}
var RBe={RBa}
var RBf={RBa}
var RBg={RBa}
var RBh={RBa}
var RBi={RBa}

# states with red and without blue
var Rba={4,6}
var Rbb={Rba}
var Rbc={Rba}
var Rbd={Rba}
var Rbe={Rba}
var Rbf={Rba}
var Rbg={Rba}
var Rbh={Rba}
var Rbi={Rba}

# states without red and with blue
var rBa={1,3}
var rBb={rBa}
var rBc={rBa}
var rBd={rBa}
var rBe={rBa}
var rBf={rBa}
var rBg={rBa}
var rBh={rBa}
var rBi={rBa}

# states without red and without blue
var rba={0,2}
var rbb={rba}
var rbc={rba}
var rbd={rba}
var rbe={rba}
var rbf={rba}
var rbg={rba}
var rbh={rba}
var rbi={rba}

# states with green and with blue
var GBa={3,7}
var GBb={GBa}
var GBc={GBa}
var GBd={GBa}
var GBe={GBa}
var GBf={GBa}
var GBg={GBa}
var GBh={GBa}
var GBi={GBa}

# states with green and without blue
var Gba={2,6}
var Gbb={Gba}
var Gbc={Gba}
var Gbd={Gba}
var Gbe={Gba}
var Gbf={Gba}
var Gbg={Gba}
var Gbh={Gba}
var Gbi={Gba}

# states without green and with blue
var gBa={1,5}
var gBb={gBa}
var gBc={gBa}
var gBd={gBa}
var gBe={gBa}
var gBf={gBa}
var gBg={gBa}
var gBh={gBa}
var gBi={gBa}

# states without green and without blue
var gba={0,4}
var gbb={gba}
var gbc={gba}
var gbd={gba}
var gbe={gba}
var gbf={gba}
var gbg={gba}
var gbh={gba}
var gbi={gba}

# B[RGB]
a,0,0,0,0,0,7,7,7,7
a,0,0,0,0,1,6,7,7,7
a,0,0,0,0,2,5,7,7,7
a,0,0,0,0,3,4,7,7,7
a,0,0,0,0,3,5,6,7,7
a,0,0,0,1,1,6,6,7,7
a,0,0,0,1,2,4,7,7,7
a,0,0,0,1,2,5,6,7,7
a,0,0,0,1,3,4,6,7,7
a,0,0,0,1,3,5,6,6,7
a,0,0,0,2,2,5,5,7,7
a,0,0,0,2,3,4,5,7,7
a,0,0,0,2,3,5,5,6,7
a,0,0,0,3,3,4,4,7,7
a,0,0,0,3,3,4,5,6,7
a,0,0,1,1,1,6,6,6,7
a,0,0,1,1,2,4,6,7,7
a,0,0,1,1,2,5,6,6,7
a,0,0,1,1,3,4,6,6,7
a,0,0,1,2,2,4,5,7,7
a,0,0,1,2,2,5,5,6,7
a,0,0,1,2,3,4,4,7,7
a,0,0,1,2,3,4,5,6,7
a,0,0,1,3,3,4,4,6,7
a,0,0,2,2,2,5,5,5,7
a,0,0,2,2,3,4,5,5,7
a,0,0,2,3,3,4,4,5,7
a,0,0,3,3,3,4,4,4,7
a,0,1,1,1,2,4,6,6,7
a,0,1,1,2,2,4,4,7,7
a,0,1,1,2,2,4,5,6,7
a,0,1,1,2,3,4,4,6,7
a,0,1,2,2,2,4,5,5,7
a,0,1,2,2,3,4,4,5,7
a,0,1,2,3,3,4,4,4,7
a,1,1,1,2,2,4,4,6,7
a,1,1,2,2,2,4,4,5,7
a,1,1,2,2,3,4,4,4,7

# B[RG], S[B]
Ba,0,0,0,0,0,6,7,7,7
Ba,0,0,0,0,1,6,6,7,7
Ba,0,0,0,0,2,4,7,7,7
Ba,0,0,0,0,2,5,6,7,7
Ba,0,0,0,0,3,4,6,7,7
Ba,0,0,0,0,3,5,6,6,7
Ba,0,0,0,1,1,6,6,6,7
Ba,0,0,0,1,2,4,6,7,7
Ba,0,0,0,1,2,5,6,6,7
Ba,0,0,0,1,3,4,6,6,7
Ba,0,0,0,2,2,4,5,7,7
Ba,0,0,0,2,2,5,5,6,7
Ba,0,0,0,2,3,4,4,7,7
Ba,0,0,0,2,3,4,5,6,7
Ba,0,0,0,3,3,4,4,6,7
Ba,0,0,1,1,2,4,6,6,7
Ba,0,0,1,2,2,4,4,7,7
Ba,0,0,1,2,2,4,5,6,7
Ba,0,0,1,2,3,4,4,6,7
Ba,0,0,2,2,2,4,5,5,7
Ba,0,0,2,2,3,4,4,5,7
Ba,0,0,2,3,3,4,4,4,7
Ba,0,1,1,2,2,4,4,6,7
Ba,0,1,2,2,2,4,4,5,7
Ba,0,1,2,2,3,4,4,4,7
Ba,1,1,2,2,2,4,4,4,7

# B[RB], S[G]
Ga,0,0,0,0,0,5,7,7,7
Ga,0,0,0,0,1,4,7,7,7
Ga,0,0,0,0,1,5,6,7,7
Ga,0,0,0,0,2,5,5,7,7
Ga,0,0,0,0,3,4,5,7,7
Ga,0,0,0,0,3,5,5,6,7
Ga,0,0,0,1,1,4,6,7,7
Ga,0,0,0,1,1,5,6,6,7
Ga,0,0,0,1,2,4,5,7,7
Ga,0,0,0,1,2,5,5,6,7
Ga,0,0,0,1,3,4,4,7,7
Ga,0,0,0,1,3,4,5,6,7
Ga,0,0,0,2,2,5,5,5,7
Ga,0,0,0,2,3,4,5,5,7
Ga,0,0,0,3,3,4,4,5,7
Ga,0,0,1,1,1,4,6,6,7
Ga,0,0,1,1,2,4,4,7,7
Ga,0,0,1,1,2,4,5,6,7
Ga,0,0,1,1,3,4,4,6,7
Ga,0,0,1,2,2,4,5,5,7
Ga,0,0,1,2,3,4,4,5,7
Ga,0,0,1,3,3,4,4,4,7
Ga,0,1,1,1,2,4,4,6,7
Ga,0,1,1,2,2,4,4,5,7
Ga,0,1,1,2,3,4,4,4,7
Ga,1,1,1,2,2,4,4,4,7

# B[GB], S[R]
Ra,0,0,0,0,0,3,7,7,7
Ra,0,0,0,0,1,2,7,7,7
Ra,0,0,0,0,1,3,6,7,7
Ra,0,0,0,0,2,3,5,7,7
Ra,0,0,0,0,3,3,4,7,7
Ra,0,0,0,0,3,3,5,6,7
Ra,0,0,0,1,1,2,6,7,7
Ra,0,0,0,1,1,3,6,6,7
Ra,0,0,0,1,2,2,5,7,7
Ra,0,0,0,1,2,3,4,7,7
Ra,0,0,0,1,2,3,5,6,7
Ra,0,0,0,1,3,3,4,6,7
Ra,0,0,0,2,2,3,5,5,7
Ra,0,0,0,2,3,3,4,5,7
Ra,0,0,0,3,3,3,4,4,7
Ra,0,0,1,1,1,2,6,6,7
Ra,0,0,1,1,2,2,4,7,7
Ra,0,0,1,1,2,2,5,6,7
Ra,0,0,1,1,2,3,4,6,7
Ra,0,0,1,2,2,2,5,5,7
Ra,0,0,1,2,2,3,4,5,7
Ra,0,0,1,2,3,3,4,4,7
Ra,0,1,1,1,2,2,4,6,7
Ra,0,1,1,2,2,2,4,5,7
Ra,0,1,1,2,2,3,4,4,7
Ra,1,1,1,2,2,2,4,4,7

# B[R], S[GB]
GBa,0,0,0,0,0,4,7,7,7
GBa,0,0,0,0,0,5,6,7,7
GBa,0,0,0,0,1,4,6,7,7
GBa,0,0,0,0,1,5,6,6,7
GBa,0,0,0,0,2,4,5,7,7
GBa,0,0,0,0,2,5,5,6,7
GBa,0,0,0,0,3,4,4,7,7
GBa,0,0,0,0,3,4,5,6,7
GBa,0,0,0,1,1,4,6,6,7
GBa,0,0,0,1,2,4,4,7,7
GBa,0,0,0,1,2,4,5,6,7
GBa,0,0,0,1,3,4,4,6,7
GBa,0,0,0,2,2,4,5,5,7
GBa,0,0,0,2,3,4,4,5,7
GBa,0,0,0,3,3,4,4,4,7
GBa,0,0,1,1,2,4,4,6,7
GBa,0,0,1,2,2,4,4,5,7
GBa,0,0,1,2,3,4,4,4,7
GBa,0,1,1,2,2,4,4,4,7

# B[G], S[RB]
RBa,0,0,0,0,0,2,7,7,7
RBa,0,0,0,0,0,3,6,7,7
RBa,0,0,0,0,1,2,6,7,7
RBa,0,0,0,0,1,3,6,6,7
RBa,0,0,0,0,2,2,5,7,7
RBa,0,0,0,0,2,3,4,7,7
RBa,0,0,0,0,2,3,5,6,7
RBa,0,0,0,0,3,3,4,6,7
RBa,0,0,0,1,1,2,6,6,7
RBa,0,0,0,1,2,2,4,7,7
RBa,0,0,0,1,2,2,5,6,7
RBa,0,0,0,1,2,3,4,6,7
RBa,0,0,0,2,2,2,5,5,7
RBa,0,0,0,2,2,3,4,5,7
RBa,0,0,0,2,3,3,4,4,7
RBa,0,0,1,1,2,2,4,6,7
RBa,0,0,1,2,2,2,4,5,7
RBa,0,0,1,2,2,3,4,4,7
RBa,0,1,1,2,2,2,4,4,7

# B[B], S[RG]
RGa,0,0,0,0,0,1,7,7,7
RGa,0,0,0,0,0,3,5,7,7
RGa,0,0,0,0,1,1,6,7,7
RGa,0,0,0,0,1,2,5,7,7
RGa,0,0,0,0,1,3,4,7,7
RGa,0,0,0,0,1,3,5,6,7
RGa,0,0,0,0,2,3,5,5,7
RGa,0,0,0,0,3,3,4,5,7
RGa,0,0,0,1,1,1,6,6,7
RGa,0,0,0,1,1,2,4,7,7
RGa,0,0,0,1,1,2,5,6,7
RGa,0,0,0,1,1,3,4,6,7
RGa,0,0,0,1,2,2,5,5,7
RGa,0,0,0,1,2,3,4,5,7
RGa,0,0,0,1,3,3,4,4,7
RGa,0,0,1,1,1,2,4,6,7
RGa,0,0,1,1,2,2,4,5,7
RGa,0,0,1,1,2,3,4,4,7
RGa,0,1,1,1,2,2,4,4,7

# S[RGB]
7,0,0,0,0,0,0,7,7,7
7,0,0,0,0,0,1,6,7,7
7,0,0,0,0,0,2,5,7,7
7,0,0,0,0,0,3,4,7,7
7,0,0,0,0,0,3,5,6,7
7,0,0,0,0,1,1,6,6,7
7,0,0,0,0,1,2,4,7,7
7,0,0,0,0,1,2,5,6,7
7,0,0,0,0,1,3,4,6,7
7,0,0,0,0,2,2,5,5,7
7,0,0,0,0,2,3,4,5,7
7,0,0,0,0,3,3,4,4,7
7,0,0,0,1,1,2,4,6,7
7,0,0,0,1,2,2,4,5,7
7,0,0,0,1,2,3,4,4,7
7,0,0,1,1,2,2,4,4,7

# B[RG], D/A[B]
rga,rgb,rgc,rgd,rge,rgf,RGg,RGh,RGi,6
rga,rgb,rgc,rgd,rge,rGf,Rgg,RGh,RGi,6
rga,rgb,rgc,rgd,rGe,rGf,Rgg,Rgh,RGi,6
rga,rgb,rgc,rGd,rGe,rGf,Rgg,Rgh,Rgi,6

# B[R], S[G], D/A[B]
rGa,rgb,rgc,rgd,rge,rgf,RGg,RGh,RGi,6
rGa,rgb,rgc,rgd,rge,rf,Rgg,RGh,RGi,6
rGa,rgb,rgc,rgd,re,rGf,Rgg,Rgh,RGi,6
rGa,rgb,rgc,rd,rGe,rGf,Rgg,Rgh,Rgi,6

# B[G], S[R], D/A[B]
Rga,rgb,rgc,rgd,rge,rgf,RGg,RGh,RGi,6
Rga,rgb,rgc,rgd,rge,rGf,gg,RGh,RGi,6
Rga,rgb,rgc,rgd,rGe,rGf,gg,Rgh,RGi,6
Rga,rgb,rgc,rGd,rGe,rGf,gg,Rgh,Rgi,6

# S[RG], D/A[B]
RGa,rgb,rgc,rgd,rge,rgf,RGg,RGh,RGi,6
RGa,rgb,rgc,rgd,rge,gf,rg,RGh,RGi,6
RGa,rgb,rgc,rgd,ge,rf,rGg,Rgh,RGi,6
RGa,rgb,rgc,gd,re,rGf,rGg,Rgh,Rgi,6

# B[RB], D/A[G]
rba,rbb,rbc,rbd,rbe,rbf,RBg,RBh,RBi,5
rba,rbb,rbc,rbd,rbe,rBf,Rbg,RBh,RBi,5
rba,rbb,rbc,rbd,rBe,rBf,Rbg,Rbh,RBi,5
rba,rbb,rbc,rBd,rBe,rBf,Rbg,Rbh,Rbi,5

# B[R], S[B], D/A[G]
rBa,rbb,rbc,rbd,rbe,rbf,RBg,RBh,RBi,5
rBa,rbb,rbc,rbd,rbe,rf,Rbg,RBh,RBi,5
rBa,rbb,rbc,rbd,re,rBf,Rbg,Rbh,RBi,5
rBa,rbb,rbc,rd,rBe,rBf,Rbg,Rbh,Rbi,5

# B[B], S[R], D/A[G]
Rba,rbb,rbc,rbd,rbe,rbf,RBg,RBh,RBi,5
Rba,rbb,rbc,rbd,rbe,rBf,bg,RBh,RBi,5
Rba,rbb,rbc,rbd,rBe,rBf,bg,Rbh,RBi,5
Rba,rbb,rbc,rBd,rBe,rBf,bg,Rbh,Rbi,5

# S[RB], D/A[G]
RBa,rbb,rbc,rbd,rbe,rbf,RBg,RBh,RBi,5
RBa,rbb,rbc,rbd,rbe,bf,rg,RBh,RBi,5
RBa,rbb,rbc,rbd,be,rf,rBg,Rbh,RBi,5
RBa,rbb,rbc,bd,re,rBf,rBg,Rbh,Rbi,5

# B[GB], D/A[R]
gba,gbb,gbc,gbd,gbe,gbf,GBg,GBh,GBi,3
gba,gbb,gbc,gbd,gbe,gBf,Gbg,GBh,GBi,3
gba,gbb,gbc,gbd,gBe,gBf,Gbg,Gbh,GBi,3
gba,gbb,gbc,gBd,gBe,gBf,Gbg,Gbh,Gbi,3

# B[G], S[B], D/A[R]
gBa,gbb,gbc,gbd,gbe,gbf,GBg,GBh,GBi,3
gBa,gbb,gbc,gbd,gbe,gf,Gbg,GBh,GBi,3
gBa,gbb,gbc,gbd,ge,gBf,Gbg,Gbh,GBi,3
gBa,gbb,gbc,gd,gBe,gBf,Gbg,Gbh,Gbi,3

# B[B], S[G], D/A[R]
Gba,gbb,gbc,gbd,gbe,gbf,GBg,GBh,GBi,3
Gba,gbb,gbc,gbd,gbe,gBf,bg,GBh,GBi,3
Gba,gbb,gbc,gbd,gBe,gBf,bg,Gbh,GBi,3
Gba,gbb,gbc,gBd,gBe,gBf,bg,Gbh,Gbi,3

# S[GB], D/A[R]
GBa,gbb,gbc,gbd,gbe,gbf,GBg,GBh,GBi,3
GBa,gbb,gbc,gbd,gbe,bf,gg,GBh,GBi,3
GBa,gbb,gbc,gbd,be,gf,gBg,Gbh,GBi,3
GBa,gbb,gbc,bd,ge,gBf,gBg,Gbh,Gbi,3

# B[R], D/A[GB]
ra,rb,rc,rd,re,rf,Rg,Rh,Ri,4

# S[R], D/A[GB]
Ra,rb,rc,rd,re,rf,g,Rh,Ri,4

# B[G], D/A[RB]
ga,gb,gc,gd,ge,gf,Gg,Gh,Gi,2

# S[G], D/A[RB]
Ga,gb,gc,gd,ge,gf,g,Gh,Gi,2

# B[B], D/A[RG]
ba,bb,bc,bd,be,bf,Bg,Bh,Bi,1

# S[B], D/A[RG]
Ba,bb,bc,bd,be,bf,g,Bh,Bi,1

# D/A[RGB]
a,b,c,d,e,f,g,h,i,0

@COLORS

0   0   0   0
1   0   0 255
2   0 255   0
3   0 255 255
4 255   0   0
5 255   0 255
6 255 255   0
7 255 255 255

@ICONS

circles

At this point, it's just figuring out the conditions under which markings are placed and whatnot.

----------

In other news, I seem to have figured out the simultaneous cases:
3gcolls-simultaneous-2state.rle
PRELIMINARY
(69.35 KiB) Downloaded 26 times

However, since I did this relatively by hand (i.e. no scripts whatsoever, only rule and paste manipulation), somebody should check this result. Here are the steps that I took:
  1. List all 71 two-glider collisions (preferably by location, NOT by result), timed a moderate number of generations (I used 24) before canonical form. (Careful! Sudden-contact collisions such as the TL+glider actually interact one generation before they "should"!)
  2. Duplicate all entries within the list, so that every collision is listed twice. For each identical pair of collisions, designate one glider in one copy and the other glider in the other copy as the key glider; I used a separate cellstate to denote this.
  3. For each collision, rotate/reflect it so that the "key" glider is traveling SE, and is in one of the two phases listed below:
    ...........
    .A.A.....B.
    ..AA...B.B.
    ..A.....BB.
    ...........
  4. Split the list into two sub-lists; one sub-list should contain all of the collisions with key gliders in Phase A, and all of the collisions with key gliders in phase B belong to the other sub-list. (If you haven't already, now would be a good time to check for duplicates, which will all be symmetrical.) (I ended up with sub-lists of length 53 and 73.)
  5. Now for the fun part: for each sub-list, take every possible pair of entries, combining them so that their key gliders are superimposed; the resultant lists of pairs can be combined into a single list. (I ended up making the non-key cellstates different within each pair.)
  6. Remove any collisions with illegal pairs of non-key gliders (a.k.a. pairs of gliders traveling in the same direction that don't stay separate).
  7. Remove any collisions in which the key gliders interact too early.
  8. At this point (at which I had a total of 1602 entries), every collision is a proper member of this set, but there are still some duplicates hiding within. Take all of the entries for which every pair of gliders interacts at the same time; set aside the rest for now.
  9. Of this subset of collisions, keep only the entries without a NW-bound glider. (Yes, it really is that simple to remove the duplicates!)
  10. Recombine this now-smaller subset with the entries set aside to obtain the final list.

An alternative option to part of the first few steps is to use what I like to call "gridding", i.e. making a Moiré pattern from two grids with slightly different offsets in space and/or time:
x = 1025, y = 364, rule = B3/S23
obo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo
47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo$b2o48b2o48b2o
48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o
48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49b
o49bo49bo49bo49bo49bo49bo49bo49bo8$3o48b3o48b3o48b3o48b3o48b3o48b3o48b
3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o$o
50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo50bo$bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50b
o50bo50bo50bo50bo50bo50bo38$obo47bobo47bobo47bobo47bobo47bobo47bobo47b
obo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo
47bobo47bobo$b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b
2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo
49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo8$b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o$2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o$2bo50bo
50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo38$obo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo
47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo$b2o
48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o
48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo49bo49bo49bo49bo
49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo8$b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o$bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo
48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo$bo
50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo50bo38$obo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bo
bo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo$b
2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b
2o48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo49bo49bo49bo49b
o49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo8$2bo50bo50bo50bo50bo50bo
50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo$b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o$bobo48bobo48bobo48bobo48bobo48bobo48bobo48bo
bo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo
48bobo48bobo38$obo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bo
bo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo$b
2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b
2o48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo49bo49bo49bo49b
o49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo9$b3o48b3o48b3o48b3o48b3o
48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o48b3o
48b3o48b3o$bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo50bo50bo50bo50bo$2bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo37$obo47bobo47bobo47bobo47bobo
47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bo
bo47bobo47bobo47bobo47bobo$b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o
48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49b
o49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo
49bo9$2b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o$b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o$3bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo50bo50bo50bo37$obo47bobo47bobo47bobo47bobo47bobo47bobo47bobo
47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bo
bo47bobo$b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b
2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo49bo
49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo9$2b2o49b2o49b
2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b
2o49b2o49b2o49b2o49b2o$2bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo
48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bo
bo48bobo$2bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo50bo50bo50bo50bo37$obo47bobo47bobo47bobo47bobo47bobo47bobo47bo
bo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo47bobo
47bobo47bobo$b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b
2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o48b2o$bo49bo49bo49bo49bo49bo
49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo49bo9$3bo50bo
50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo50bo
50bo50bo$2b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o
49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o49b2o$2bobo48bobo48bobo48bobo
48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bobo48bo
bo48bobo48bobo48bobo48bobo48bobo!

This method, which I ended up using, might be easier, as the duplications have already been taken care of, even avoiding copying the symmetric cases! (The key glider is always in the same place for this method.) However, timing adjustments still need to occur, and don't forget to sort out the cases where the gliders miss!

(If needed, I can explain any of the steps and/or why they work in more detail.)
I Like My Heisenburps! (and others)
User avatar
Extrementhusiast
 
Posts: 1636
Joined: June 16th, 2009, 11:24 pm
Location: USA

Re: Enumerating Three-Glider Collisions

Postby dvgrn » May 29th, 2017, 8:53 pm

Extrementhusiast wrote:I did so without using such a script (although using other software, in this case Mathematica, to generate what combinations made what)...
At this point, it's just figuring out the conditions under which markings are placed and whatnot.

That seems simple enough. The primary Life universes are red (binary 100), green (010) and blue (001), right? (Hmm, if you switched green and blue, then those colors would be correct in LifeHistory... but sadly I didn't add a state 7, so there are some combinations that there's no room for.)

XOR works!
Anyway, then I think we can just XOR-paste in Golly to encode simultaneous red = A+B. green = A, and blue = B universes -- or to remove a red, blue, or green universe from a combined pattern. Here's a test:

x = 96, y = 11, rule = deeperlife
14.B39.D39.F$.A10.2B27.D10.2D27.E10.2F$2.A10.2B27.D10.2D27.E10.2F$3A
37.3D37.3E4$13.3B37.3D37.3F$.2A10.B27.2D10.D27.2E10.F$2.2A10.B27.2D
10.D27.2E10.F$.A39.D39.E!

XOR-pasting the first group of gliders onto the second, or the second onto the first, produces the third group, the purple and yellow gliders at the right. Pasting one of the first two groups onto the third group produces the remaining group. And when you run the purple and yellow group, the blue and green universes die out as they should, and all that's left is the correct red A+B combination. Looks good!

But XOR doesn't replace objtracklife2 --
I still like the objtracklife2 rule better for checking interactions. It will notice a change due to a Heisenburp reaction even if the resulting Heisenspark dies out with no permanent consequences. I kind of expect to run into a few such cases among the three-glider collisions, and it would be good to track them.

(If anyone is ever crazy enough to try to enumerate a subset of the 4G collisions somehow starting with the 3G ones, there might just possibly be some interesting recipes that would otherwise be missed, maybe with the Heisenburp glider being kicked back to hit the dying Heisenspark. But see below.)

Extrementhusiast wrote:In other news, I seem to have figured out the simultaneous cases ...
(If needed, I can explain any of the steps and/or why they work in more detail.)

It seems clear enough on first inspection. I certainly don't see any holes in your method immediately, though I'll try to think about it some more. Looks like your magic number for simultaneous collisions is 23190/15 = 1546.

Same number from a different search (I hope)
I'm planning to take a somewhat different approach, based on what will have to be done anyway to enumerate all the distinct 3G cases where two of the gliders collide first:

  • Start with each of the 71 two-glider collisions, rewound by let's say 24 ticks. Call the start time T=-24.
  • Find the reaction envelope of the 2G collision.
  • Enumerate all lanes, with gliders coming from all four possible directions, where some part of the lane touches some part of the reaction envelope.
  • Test all gliders on each lane that could possibly interact with the two-glider reaction.
    • Start with a glider just beyond the reaction envelope on that lane, that are traveling away from the reaction.
    • Try every glider spacetime location backwards from there until the gliders start hitting a completely stabilized pattern.
    • Keep all 3G combinations that interact in any way.
    • (Use objtracklife2 to make sure that the apparent noninteractions aren't really Heisenburps.)
  • Of these sets of three interacting gliders, throw out those that start interacting before T=0. These will be enumerated elsewhere.
  • Then sort out those that start interacting at T=0. If all goes well, there should be a total of 1546 of them.
  • The rest are all distinct 3-glider collisions. Like the simultaneous 3Gs, many of them will produce output identical to other collisions, but they should all still be counted as distinct cases.
Argh, kickbacks...
I'm not looking forward to troubleshooting the cases where there's an output glider that can be kicked back into a still-active reaction... but it seems clear that once the reaction settles, there's only one more set of four kickbacks that should be considered distinct from the more-delayed kickbacks. A higher delay doesn't do anything from a 3G point of view -- the "same glider" ends up hitting the "same junk" in the exact same way, after everything gets a little older.

From the point of view of 4G collisions, that's actually not good enough. A fourth glider could hit a piece of junk, or the last dying spark from let's say the 2-glider-mess reaction, and prolong it for long enough that a very long-delayed kickback glider might do something unique.

Unfortunately almost none of these "4-glider mess" reactions are going to be very interesting, except maybe a few that produce a really rare still life. There will be a large number of 4-glider-mess collisions, a truly horribly large number, so that will certainly happen occasionally...!

Conclusion
The moral of this story is: don't anyone ever try to enumerate all 4G collisions. If anything, maybe try to work on subsets like 4G simultaneous collisions, or 4G collisions based on each 3G collision that doesn't produce a switch engine or an output glider or *WSS.

I'm looking forward to having a nice complete list of all the small constellations that can be constructed with three gliders, though...!
dvgrn
Moderator
 
Posts: 3858
Joined: May 17th, 2009, 11:00 pm
Location: Madison, WI


Return to Scripts

Who is online

Users browsing this forum: No registered users and 1 guest