The Hunt for a Strong Pascal-Mod-3 Replicator

[muzik]

This thread is for research into the existence of modulo-3 (and potentially higher) linear replicators in 2-state rules, which fulfil the requirements for "strength" (i.e. units should be able to be removed arbitrarily at any generation without impacting the unit cell behaviour of the replicator).

The following is an ideal domino case, from a 3-state rule:

Code: Select all

x = 1, y = 2, rule = MarBlocks-3-rep
A$A!

Here's generation 12 of that replicator:

Code: Select all

x = 25, y = 2, rule = MarBlocks-3-rep
A5.A11.A5.A$A5.A11.A5.A!

Here's the same generation, but we remove one of the inner units:

Code: Select all

x = 25, y = 2, rule = MarBlocks-3-rep
A5.A17.A$A5.A17.A!

It can be clearly seen that removing that inner unit did not cause the replicator to explode or perform any other unexpected behavioural and two copies of said arrangement can be seen in generations 27, 81, 243, ...

Likewise, here's generation 12 but we replace one of the inner state-1 units with state-2, demonstrating this also doesn't explode or die out and reappears at generations 3^n accordingly:

Code: Select all

x = 25, y = 2, rule = MarBlocks-3-rep
A5.A11.B5.A$A5.A11.B5.A!

----

Now there are plenty of known modulo-3 replicators in 2-state rules, in which one copy will replicate infinitely, however all seem to fail the strength requirement. Here's a 3c/6 example:

Code: Select all

x = 4, y = 3, rule = B2ekn3aceiy4kwy5jqy6cn7c/S1c2ac3aeinr4ik5jq6eik7c
b2o$o2bo$b2o!

The configuration at T=72 (6*12):

Code: Select all

x = 76, y = 3, rule = B2ekn3aceiy4kwy5jqy6cn7c/S1c2ac3aeinr4ik5jq6eik7c
b2o16b2o34b2o16b2o$o2bo14bo2bo32bo2bo14bo2bo$b2o16b2o34b2o16b2o!

The above configuration, but we delete one of the inner units or replace it with a state-2 equivalent:

Code: Select all

x = 76, y = 3, rule = B2ekn3aceiy4kwy5jqy6cn7c/S1c2ac3aeinr4ik5jq6eik7c
b2o16b2o52b2o$o2bo14bo2bo50bo2bo$b2o16b2o52b2o!

Code: Select all

x = 76, y = 3, rule = B2ekn3aceiy4kwy5jqy6cn7c/S1c2ac3aeinr4ik5jq6eik7c
b2o16b2o32b2o2b2o14b2o$o2bo14bo2bo31b6o13bo2bo$b2o16b2o32b2o2b2o14b2o
!

In this case, replication becomes completely chaotic, which is not what was observed in the 3-state rule.

For this 5c/10 case, things eventually get explosive instead:

Code: Select all

x = 5, y = 4, rule = B3-e4ny56i7e/S2-ck3r4-nt5jq6
b3o$2ob2o$2ob2o$b3o!

Code: Select all

x = 125, y = 4, rule = B3-e4ny56i7e/S2-ck3r4-nt5jq6
b3o27b3o87b3o$2ob2o25b2ob2o85b2ob2o$2ob2o25b2ob2o85b2ob2o$b3o27b3o87b
3o!

Code: Select all

x = 125, y = 6, rule = B3-e4ny56i7e/S2-ck3r4-nt5jq6
92bo$b3o27b3o56bobobo26b3o$2ob2o25b2ob2o55b5o25b2ob2o$2ob2o25b2ob2o55b
5o25b2ob2o$b3o27b3o56bobobo26b3o$92bo!

The list goes on - despite having a good sample size of mod-3 replicators, none of them meet our strength requirements.

Code: Select all

x = 4, y = 3, rule = B2ei3ceikr4aejty5iry6c7c8/S1c2aci3aikny4cejkqry5ckqy6ek78
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ein3ceijq4acrwy5ny6-in78/S1c2-ik3anq4aeiqtyz5-einr6ain7c
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2en3ceijq4acrwy5ny6-in78/S1c2-ik3anq4aeiqtyz5-einr6ain7c
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3aeijn4enw5kqy6aei8/S1c2ac3acq4ek5acnq6an7
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eiq5cy6e7c8/S1c2aci3ajy4n8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2en3ei5iny6a7e8/S1c2aci3ay4ny5c6e
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eij5y6a8/S1c2aci3a4ae5j6a8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eijr4z5iy8/S1c2acn3a4y5r8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eij4ceq5ny7c8/S1c2ac3a4aj8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eij4n5iy7e/S1c2ac3a4iqwy7e8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eijn4w5y8/S1c2ac3acj6n7e8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eij4n5y8/S1c2ac3a4i5n6k8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eijk4kt5qy6c8/S1c2ace3a4ajw5y8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eij4t5cy7e/S1c2ac3a4e8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3eijqr4e5ekry6n8/S1c2ac3a4ciq5a6ik
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2en3-knqr4cijkwyz5cjny6aik8/S1c2ac3-er4aijqw5aejq6cei7
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2en3eijr4ekn5qry6a7c8/S1c2ac3acknq4ikz5jnry6e8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ein3-knqy4twyz5ijnry7c/S1c2ac3-cenq4aeinry5r6ci7e
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ek3aeijy4jnty5-acir6ikn/S1c2-ik3ajnqy4anwyz5jk6cn8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3-kq4ejr5iknry6n8/S1c2acn3aky4-ckntw5c6ac8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ein3aeijq4ik5acky6ek8/S1c2-ek3-eknq4arwy5qr6c7e8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ein3-cknr4eiqw5jy6ek8/S1c2-ek3ary4aceiy5ekq6-i78
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ek3-cnqy4jntwz5-eikn6ack8/S1c2acn3-cenq4aeijnw5acnqr6c7c
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e3-kqy4jknty5enry6ak7c/S1c2acn3ajnqy4aenqyz5acjkn6ac7c8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2eik3-nr4ijkntwy5ajkny8/S1c2ace3ainy4aceqy5cnqry6-e7c8
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e35y/S1c2ace3an4i
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2e35y7e/S1c2ace3an
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2ek3aeik4cinry5acry6e7c8/S1c2-kn3aiky4eijny5jn6i
b2o$o2bo$b2o!

Code: Select all

x = 4, y = 3, rule = B2en3-cny4iy5-acik6c7c/S1c2acn3ajnr4ejkqy5acer6-kn8
b2o$o2bo$b2o!

Try advancing any of these twelve period cycles, deleting one of the two middle units and continuing further - all of them will either end up exploding, replicating chaotically or becoming puffer engines, proving that despite the massive amount of mod-3 replicators we have above, none of these are strong. wwei explains why:

I think I know what's going on, and I also want to establish some replicator theory. Almost all pascal mod 3 replicators in isotropic rules do so not with two different STATES; instead, what would be a different state is done with a replicator copy that is shifted in time, space, or both. For example, with that replicator, its "state 2" is just a copy of the original replicator shifted forwards in 3 generations.

Code: Select all

x = 52, y = 5, rule = B3-cqy4ajq5ry6i8/S23-cejk4t5acj7c
25b2o$o2bo20bo2bo20bo2bo$o2bo19bo4bo19bo2bo$o2bo20bo2bo20bo2bo$25b2o!

This led me to making "tables" describing how replicators replicate. They're not perfect, but they work for the vast majority of well-behaved 1D replicators. First, we describe an unshifted copy using A, and the lack of a copy using 0. Then we enumerate all relevant collisions.
Most replicators are just sierpinski replicators. In this case, we have 0+0=0, 0+A=A, but A+A=0.
But with this replicator, we instead get a time-shifted copy. Since it's shifted 3 generations ahead, I denote this with Avvv (or A3v). If it were shifted 3 cells left, I'd use ALLL (or A3L). If it were shifted 3 generations behind, I'd use A^^^ (or A3^). If it were shifted 3 cells up, I'd use AUUU (or A3U). So, what does the table itself look like?
0+0=0
0+A=A
A+A=A3v
A+A3v=0
As a result, this happens.

Code: Select all

                  A
                A   A
              A   A3v A
            A           A
          A   A       A   A
        A   A3v A   A   A3v A
      A           A3v         A
    A   A       A3v A3v     A   A
  A   A3v A   A3v A6v A3v A   A3v A
A                                   A

Wait. A6v? Where did that come from? That's not in the table! To answer this, we have to remember that the absolute phases don't matter; only the relative phases do. A3v and A3v are in the same phase, so they collide in the same way that A and A do. Since they're already shifted 3 generations ahead, this collision shifts them another 3 generations ahead, making A6v. At the end, all the timings are "orchestrated" to annihilate everything in the middle. The phase shift between A3v and A6v is still 3 generations, so they still annihilate like with A and A3v.
With all of that theory established, let's go back to the exploding pattern and go 9 cycles or 405 generations in, when the failure happens.

Code: Select all

x = 316, y = 9, rule = B3-cqy4ajq5ry6i8/S23-cejk4t5acj7c
171b2o18b2o$119bo28bo22bobo16bobo$97b2o18b5o24b5o19b4o16b4o23b2o48bo20b
o$b2o22b2o69b4o16b2obo3bo20bo3bob2o19b2o18b2o23b4o21b2o22b3ob2o14b2ob
3o22b2o$o2bo20bo2bo67b2o2b2o15bo6bo20bo6bo15b3o24b3o18b2o2b2o19bo2bo20b
3o3bo14bo3b3o20bo2bo$b2o22b2o69b4o16b2obo3bo20bo3bob2o19b2o18b2o23b4o
21b2o22b3ob2o14b2ob3o22b2o$97b2o18b5o24b5o19b4o16b4o23b2o48bo20bo$119b
o28bo22bobo16bobo$171b2o18b2o!

Here, two replicators collide, but instead of producing nothing or another replicator, they instead explode. Why? Because A+A6v=boom. As long as you don't delete any replicators, things work like usual. But as soon as you do, you can get pathological collisions that would have never happened otherwise. This is why removing one replicator unit broke the whole thing.
A strong pascal mod 3 replicator should be possible with an asymmetric unit that flips when two of them collide. If we label a flipped unit as A' and use 0+0=0; 0+A=A; A+A=A'; A+A'=0, then the flipped unit really does act like a state 2, since collisions between flipped units simply flip them back (A'+A'=A), giving us a strong pascal mod 3 replicator.

The final paragraph brings to mind the following replicator:

Here's another cool one (it's so tantalisingly close to working in a rule containing gliders and having replicator ships):

Code: Select all

x = 3, y = 2, rule = B2i3aij4a/S234i
3o$obo!

Notice that the copies it produces that violate Rule 90 are shifted downward by 1 cell.

The "state 2" units are merely shifted down by one cell, and the replicator overall fails the strength test. However, if the state 2 units were also vertically mirrored, then we could exploit the isotropy of the rule to produce a replicator which truly does replicate strongly with modulo 3, since flipping it twice would get us back to the original configuration (i.e. "A6v" = "A").

So the question arises: can we find an explicit example?

[wwei47]

So the question arises: can we find an explicit example?

There is a simple strong pascal mod 3 replicating wave in a width-2 tube. Unfortunately, there's likely no way to make it work outside these conditions.

Code: Select all

x = 1, y = 1, rule = B2/S:T0,2
o!

[wildmyron]

I think this 4c/4 replicator fits the criteria:

Code: Select all

x = 3, y = 4, rule = B2a3aeiq4cjrwz5a6ck/S2ck3enqr4eknwz5eq
o$3o$2bo$2bo!

Found with LLS

Edit: punctuation

[muzik]

I think this 4c/4 replicator fit's the criteria:

Code: Select all

x = 3, y = 4, rule = B2a3aeiq4cjrwz5a6ck/S2ck3enqr4eknwz5eq
o$3o$2bo$2bo!

Found with LLS

Very impressive! I've been awaiting an example like this for many years at this point, so it's great to finally have this ticked off the list. I've updated the collection to version 1.5 to accommodate this and any future examples that may arise.

I suppose the next thing to look for would be the three-copy version of this, i.e. a replicator bound by the rule in which there are always three copies at generation (3^n)*period. We already have examples for Rule 150, the two-state version of this:

Code: Select all

x = 1, y = 5, rule = B2a/S1e3eiy5i
o$o2$o$o!

Here's the three-state equivalent on an invisible torus:

Code: Select all

x = 1, y = 2, rule = ModuloThreeTripleReplicator1D:T0,2
o$o!
[[ COLOR BOUNDED 0 0 0 ]]

It should be relatively simple to find a replicator that follows this strongly in a 3-state rule, but knocking that down to a 2-state rule seems like an interesting challenge.

Here's the WolframAlpha page for that rule: https://www.wolframalpha.com/input/?i=t ... 8%2C+k%3D3

...On the other hand, we also haven't found any modulo-3 2D replicators yet, be they weak or strong...

[wildmyron]

I suppose the next thing to look for would be the three-copy version of this, i.e. a replicator bound by the rule in which there are always three copies at generation (3^n)*period. We already have examples for Rule 150, the two-state version of this:

Code: Select all

x = 1, y = 5, rule = B2a/S1e3eiy5i
o$o2$o$o!

Here's the three-state equivalent on an invisible torus:

Code: Select all

x = 1, y = 2, rule = ModuloThreeTripleReplicator1D:T0,2
o$o!
[[ COLOR BOUNDED 0 0 0 ]]

It should be relatively simple to find a replicator that follows this strongly in a 3-state rule, but knocking that down to a 2-state rule seems like an interesting challenge.

Here's the WolframAlpha page for that rule: https://www.wolframalpha.com/input/?i=t ... 8%2C+k%3D3

I gave that a go but the constraints are more complicated. I ran searches for a range of repunit sizes, symmetries and different replicator speeds but they all came up negative.

OTOH, here's an interesting 6c/6 replicator type pattern which looks like the mod-4 version of the above result. There's a strange kind of XOR nature to the units which represent '1', '2', and '3' which makes me dubious, but I think it meets all your criteria.

Code: Select all

x = 3, y = 25, rule = B2akn3air4akny5kn8/S2-ae3jr4ktw6ci8
o$o2$2bo$2bo7$bo$bo$bo7$o$2o$bo$b2o$2bo!