Dependent Reflector Terminology and Analysis

[dvgrn]

P55 glider loop found by me, trivially reduced by galoomba...

P69 glider loop found by me, trivially reduced by iNoMed...

Time for a minor nitpick on terminology, I think: it doesn't seem like any of these should be referred to as "glider loops", without the word "dependent" in there somewhere at least. "Dependent" would give a good hint that you can't remove one of the gliders from the "loop" and expect the thing to still work.

However, there isn't actually any kind of signal loop at all in these things -- it's two or four separate segments. So any use of "loop" seems like not such a good idea. You wouldn't call something like this a "glider loop", right? The "signals" are traveling much faster than lightspeed through the gun, and therefore they're not actually signals:

...

You could argue that the signals are sub-lightspeed, it's just that the signal corresponding to each glider is actually the first one that wouldn't appear if it weren't there. I do think "dependent glider loop" is a good clarification to make, though

It's not a question of speed, it's just that signals are NOT looping, there is no way in which a signal can return to the same position in the structure.

To repeat my reply on Talk:Dependent reflector loop: I also think using "loop" is confusing for these oscillators -- with a dependent reflector, a "hole" in the input stream doesn't become a "hole" in the output stream, therefore the output stream consists of "completely new" gliders (e.g. I don't see a way to unambiguously decide which output glider "corresponds to" which input glider). These look like loops geometrically, but I think the term doesn't capture that.

I don't know what's the best way to describe oscillators of this type. Personally, I like the proposed alternative "dependent glider shuttle", even if it turns out I'm in the minority for this one.

Looking at it all again, I think that there actually are perfectly viable signals in a dependent reflector loop, and that there is an unambiguous way to decide which output glider corresponds to which input glider, and that (completely contradicting what I said above!) there's no problem with super-lightspeed "signal" travel, if you pick the right correspondence.

Here's a version of the example I gave in the talk page for dependent reflector, showing the eight signals in the p31 dependent reflector loop -- all in glider form, as it happens, though that won't always be possible in the general case. Each signal has a cycle length of 8 * 31 = 248 ticks.

Code: Select all

x = 45, y = 48, rule = LifeSuper
20.R$20.R$20.R$20.R$20.R$18.R.R.R5.2pA$19.3R5.2pA.pA5.2pA$20.R7.pA.2pA
4.2pA$29.2pA2$2.2pA8.pA6.2M3.3pA$2.2pA6.3pA7.2M.pA3.pA$9.pA9.M3.pA3.pA
$9.2pA12.pA.2pA7.2pA$34.pA.pA$20.R8.pA6.pA$19.3R8.pA5.2pA$3.2pA13.R.R
.R5.3pA$2pA.2pA6.3pA6.R$2.pA5.pA4.pA6.R$8.pA3.pA7.R$7.pA12.R$6.pA3.pA
9.R$6.pA.2pA26.pA$7.pA29.2pA$36.2pA2$7.2pA$6.2pA29.pA$8.pA26.2pA.pA$
34.pA3.pA$37.pA$32.pA3.pA$31.pA4.pA5.pA$31.3pA6.2pA.2pA$14.3pA23.2pA$
7.2pA5.pA$8.pA6.pA$8.pA.pA$9.2pA7.2pA.pA12.2pA$17.pA3.pA3.pA9.pA$17.pA
3.pA.2pA7.3pA6.2pA$18.3pA3.2pA6.pA8.2pA2$14.2pA$7.2pA4.2pA.pA$7.2pA5.
pA.2pA$15.2pA!
[[  STOP 248 ]]

You can see the influence of the chosen glider working its way around the loop, and confirm that that influence gets back to its starting point after 248 ticks. And if you remove the glider, the influence of the missing signal also makes its way around the loop in 248 ticks -- though you do have to remove each dependent reflector as you go along, as soon as it's not working as intended, to keep chaos from spreading and interrupting the experiment.

[confocaloid]

My objection is that you cannot see which gliders in the input stream of a dependent reflectors become which gliders in the output stream after a given number of ticks. The example proposed below uses a multi-state ruletable to track propagation of cellstates -- but those don't follow B3/S23, and are not valid Life signals.

I believe that in plain two-state B3/S23, there is no authoritative procedure that would allow to determine experimentally how many gliders are in a circuit containing dependent reflectors. Without dependent reflectors, you could interleave removing visible gliders one-by-one and evolving the remaining pattern, until there are no gliders anymore; that is a direct way to count gliders in a loop. With dependent reflectors, attempting the same destroys the circuit.

...

To repeat my reply on Talk:Dependent reflector loop: I also think using "loop" is confusing for these oscillators -- with a dependent reflector, a "hole" in the input stream doesn't become a "hole" in the output stream, therefore the output stream consists of "completely new" gliders (e.g. I don't see a way to unambiguously decide which output glider "corresponds to" which input glider). These look like loops geometrically, but I think the term doesn't capture that.

I don't know what's the best way to describe oscillators of this type. Personally, I like the proposed alternative "dependent glider shuttle", even if it turns out I'm in the minority for this one.

Looking at it all again, I think that there actually are perfectly viable signals in a dependent reflector loop, and that there is an unambiguous way to decide which output glider corresponds to which input glider, and that (completely contradicting what I said above!) there's no problem with super-lightspeed "signal" travel, if you pick the right correspondence.

Here's a version of the example I gave in the talk page for dependent reflector, showing the eight signals in the p31 dependent reflector loop -- all in glider form, as it happens, though that won't always be possible in the general case. Each signal has a cycle length of 8 * 31 = 248 ticks.

Code: Select all

x = 45, y = 48, rule = LifeSuper
20.R$20.R$20.R$20.R$20.R$18.R.R.R5.2pA$19.3R5.2pA.pA5.2pA$20.R7.pA.2pA
4.2pA$29.2pA2$2.2pA8.pA6.2M3.3pA$2.2pA6.3pA7.2M.pA3.pA$9.pA9.M3.pA3.pA
$9.2pA12.pA.2pA7.2pA$34.pA.pA$20.R8.pA6.pA$19.3R8.pA5.2pA$3.2pA13.R.R
.R5.3pA$2pA.2pA6.3pA6.R$2.pA5.pA4.pA6.R$8.pA3.pA7.R$7.pA12.R$6.pA3.pA
9.R$6.pA.2pA26.pA$7.pA29.2pA$36.2pA2$7.2pA$6.2pA29.pA$8.pA26.2pA.pA$
34.pA3.pA$37.pA$32.pA3.pA$31.pA4.pA5.pA$31.3pA6.2pA.2pA$14.3pA23.2pA$
7.2pA5.pA$8.pA6.pA$8.pA.pA$9.2pA7.2pA.pA12.2pA$17.pA3.pA3.pA9.pA$17.pA
3.pA.2pA7.3pA6.2pA$18.3pA3.2pA6.pA8.2pA2$14.2pA$7.2pA4.2pA.pA$7.2pA5.
pA.2pA$15.2pA!
[[  STOP 248 ]]

You can see the influence of the chosen glider working its way around the loop, and confirm that that influence gets back to its starting point after 248 ticks. And if you remove the glider, the influence of the missing signal also makes its way around the loop in 248 ticks -- though you do have to remove each dependent reflector as you go along, as soon as it's not working as intended, to keep chaos from spreading and interrupting the experiment.

[dvgrn]

I believe that in plain two-state B3/S23, there is no authoritative procedure that would allow to determine experimentally how many gliders are in a circuit containing dependent reflectors.

I'm pretty sure there's a very clear way to determine the number of signals in a dependent-reflector loop.

For any period-N dependent reflector, make a copy of it and remove its input glider. Run for N ticks. EDIT 7/5/2023: N ticks is usually but not always sufficient -- see this revision. Run both the original and the copy until gliders stop emerging on the output lane in the "input removed copy". The glider that's missing in the copy but present in the original is the input glider's corresponding output glider.

Any glider that exists in the original and in the copy is obviously _not_ the output glider for that input. The output glider is the unique glider that is present in the original but not present in the copy with the input glider removed.

Once you know the inputs and outputs of the reflectors, there's no difficulty in calculating the cycle length of the entire loop -- and there's also no difficulty in finding and labeling each unambiguous signal that's traveling around the unambiguous loop.

The fact that you can't remove a signal from one of these loops doesn't mean that they're not valid signals, or that it's not really a loop. You can perfectly well build Herschel loops with the property that you can't remove one Herschel from the loop without causing the loop to self-destruct -- but the Herschel loop is still clearly a loop, and the Herschels are still clearly signals traveling around in it.

[confocaloid]

I believe that in plain two-state B3/S23, there is no authoritative procedure that would allow to determine experimentally how many gliders are in a circuit containing dependent reflectors.

I'm pretty sure there's a very clear way to determine the number of signals in a dependent-reflector loop.

For any period-N dependent reflector, make a copy of it and remove its input glider. Run for N ticks.

Any glider that exists in the original and in the copy is obviously _not_ the output glider for that input. The output glider is the unique glider that is present in the original but not present in the copy with the input glider removed.

Once you know the inputs and outputs of the reflectors, there's no difficulty in calculating the cycle length of the entire loop -- and there's also no difficulty in finding and labeling each unambiguous signal that's traveling around the unambiguous loop.

The fact that you can't remove a signal from one of these loops doesn't mean that they're not valid signals, or that it's not really a loop. You can perfectly well build Herschel loops with the property that you can't remove one Herschel from the loop without causing the loop to self-destruct -- but the Herschel loop is still clearly a loop, and the Herschels are still clearly signals traveling around in it.

The proposed procedure doesn't work. I took a dependent reflector from the p26 glider shuttle article and added parts of input and output streams to it. The pattern below shows two copies of the result. As required, the copy on the right has one input glider removed. Now, if I run the patterns for N=26 ticks, then

"the unique glider that is present in the original but not present in the copy with the input glider removed"

refers to the removed input glider, which (present on the left) is moved diagonally towards the dependent reflector but didn't yet reach it. I think it is obvious that this glider cannot be "the corresponding output glider" -- even with the assumption that it is possible to define a canonical correspondence between individual gliders.

Code: Select all

x = 156, y = 48, rule = B3/S23
20b2o98b2o$20bobo97bobo$23bo2b2o95bo2b2o$21b2obo2bo93b2obo2bo$20bobob
2o94bobob2o$21bo99bo4$23b2o98b2o$22bo2bo96bo2bo$22bobo97bobo$22bobo97b
obo$17b2o4bo93b2o4bo$16bobo97bobo$16bo99bo$15b2o98b2o2$20bobo97bobo$
20b2o12b2o84b2o12b2o$21bo11b2o86bo11b2o$35bo99bo3$15bo99bo$13b2o26bo
71b2o26bo$14b2o24b2o72b2o24b2o$40bobo97bobo4$7bobo97bobo$7b2o38b2o58b
2o38b2o$8bo37b2o60bo37b2o$48bo99bo3$2bo99bo$2o52bo45b2o52bo$b2o50b2o
46b2o50b2o$53bobo97bobo5$60b2o$59b2o$61bo!

[Scorbie]

I believe that in plain two-state B3/S23, there is no authoritative procedure that would allow to determine experimentally how many gliders are in a circuit containing dependent reflectors.

I'm pretty sure there's a very clear way to determine the number of signals in a dependent-reflector loop.

For any period-N dependent reflector, make a copy of it and remove its input glider. Run for N ticks.

Any glider that exists in the original and in the copy is obviously _not_ the output glider for that input. The output glider is the unique glider that is present in the original but not present in the copy with the input glider removed.

Once you know the inputs and outputs of the reflectors, there's no difficulty in calculating the cycle length of the entire loop -- and there's also no difficulty in finding and labeling each unambiguous signal that's traveling around the unambiguous loop.

The fact that you can't remove a signal from one of these loops doesn't mean that they're not valid signals, or that it's not really a loop. You can perfectly well build Herschel loops with the property that you can't remove one Herschel from the loop without causing the loop to self-destruct -- but the Herschel loop is still clearly a loop, and the Herschels are still clearly signals traveling around in it.

The proposed procedure doesn't work. I took a dependent reflector from the p26 glider shuttle article and added parts of input and output streams to it. The pattern below shows two copies of the result. As required, the copy on the right has one input glider removed. Now, if I run the patterns for N=26 ticks, then

"the unique glider that is present in the original but not present in the copy with the input glider removed"

refers to the removed input glider, which (present on the left) is moved diagonally towards the dependent reflector but didn't yet reach it. I think it is obvious that this glider cannot be "the corresponding output glider" -- even with the assumption that it is possible to define a canonical correspondence between individual gliders.

Code: Select all

x = 156, y = 48, rule = B3/S23
20b2o98b2o$20bobo97bobo$23bo2b2o95bo2b2o$21b2obo2bo93b2obo2bo$20bobob
2o94bobob2o$21bo99bo4$23b2o98b2o$22bo2bo96bo2bo$22bobo97bobo$22bobo97b
obo$17b2o4bo93b2o4bo$16bobo97bobo$16bo99bo$15b2o98b2o2$20bobo97bobo$
20b2o12b2o84b2o12b2o$21bo11b2o86bo11b2o$35bo99bo3$15bo99bo$13b2o26bo
71b2o26bo$14b2o24b2o72b2o24b2o$40bobo97bobo4$7bobo97bobo$7b2o38b2o58b
2o38b2o$8bo37b2o60bo37b2o$48bo99bo3$2bo99bo$2o52bo45b2o52bo$b2o50b2o
46b2o50b2o$53bobo97bobo5$60b2o$59b2o$61bo!

1. Doesn't your argument also apply to independent glider loops as well?

2. Here's my take.

This topic is related to how we identify moving objects.
It's easier to see a gun as a stream of moving gliders than a static pattern which appends a glider to itself every cycle.
Just as people see the illusion of a barberpole moving upwards where it's actually rotating.

While the gun looks like the above to almost everyone, it seems like people disagree what a dependent reflector cycling gliders look like.

I do see a loop, so I'll try to explain.
Prepare two continuous glider streams. It has a start. It has the first glider but continues indefinitely.
Shoot one continuous glider stream to a dependent relector.
The reflector will indefinitely reflect the gliders.
Don't do anything to the other.

- If we see the output gliders we have a one-to-one correspondence:
- Where the reflected glider is - vs - where the non-reflected glider is. (where the glider would have been if they weren't reflected)
- Similarly the input gliders have a trivial one-to-one correspondence.
- The gliders that are reacting with the reflector (should be 1 but I want to be general enough) correspond to the where the non-reflected gliders are.

Similarly in a glider loop-or-shuttle-whatever-it-is-called, there is a correspondence to where the glider would have been without the reflector vs where it currently is. (And it can be reacting with the reflector at current generation)

The reason to why I see a loop is that I see the dependent reflector as an unstable enzyme reaction,
where the substrate is the glider and the enzyme is the dependent refletor.
(Substrate Glider + Reflector) --> (Glider & Reflector Complex) --> (Product Glider + Reflector)
Actually this is the case for independent reflectors to me, but anyway.

That said I'm okay with whatever name you all will come up with, loop or no loop, as I trust the members that they will come up with a sane name.
I just wanted to chime in to provide some info that might help a resolution.

[confocaloid]

1. Doesn't your argument also apply to independent glider loops as well?

Well, I think the proposed procedure from the earlier post doesn't work for non-dependent reflectors, either -- in the way it is stated, it does not answer question "where is the output glider that corresponds to a given input glider after some number of ticks", regardless of the nature of the reflector.

However, for non-dependent reflectors there is a different procedure that does work: send just one input glider into a reflector (along the correct input lane at a timing correctly aligned with the period of the reflector), and wait until an output glider comes out. It is guaranteed that there will be exactly one output glider and the reflector will survive the experiment. The only output glider is the answer (i.e. the glider that corresponds to the only input glider). This procedure works for a non-dependent reflector, but fails for a dependent reflector.

I do see a loop, so I'll try to explain.
Prepare two continuous glider streams. It has a start. It has the first glider but continues indefinitely.
Shoot one continuous glider stream to a dependent relector.
The reflector will indefinitely reflect the gliders.
Don't do anything to the other.

- If we see the output gliders we have a one-to-one correspondence:
- Where the reflected glider is - vs - where the non-reflected glider is. (where the glider would have been if they weren't reflected)
- Similarly the input gliders have a trivial one-to-one correspondence.
- The gliders that are reacting with the reflector (should be 1 but I want to be general enough) correspond to the where the non-reflected gliders are.

Similarly in a glider loop-or-shuttle-whatever-it-is-called, there is a correspondence to where the glider would have been without the reflector vs where it currently is. (And it can be reacting with the reflector at current generation)

Let A be the glider stream that goes into the dependent reflector, B the glider stream that comes out of the dependent reflector, and let C be the other glider stream that just continues indefinitely without any interactions.

I can run the whole pattern for some number of ticks (e.g. T = MN ticks, a multiple of the period N of the streams/the dependent reflector).
For stream C, it is easy to see movement of individual gliders, and it is easy to see the location at time T for any specific glider that was present at time 0. In other words, individual gliders in C can be tracked.
For stream B, it is also easy to see movement of individual gliders (away from the dependent reflector).
For stream A, individual moving gliders can be tracked only as long as they don't reach the dependent reflector. Then the input glider hits the active reaction of the dependent reflector and merges with it. If we try to imagine that the input glider from stream A "spends some time inside the reflector and then comes out in stream B", then the question is how to track when and where the chosen glider comes out (i.e. what is the exact delay caused by the reflector).

(My own preferred interpretation is that gliders from A that enter the dependent reflector will never come back again; the dependent reflector works as a black hole for A. Similarly, gliders in B that move away from the dependent reflector did never exist before they were emitted by the dependent reflector. So a dependent reflector is just "a glider gun supported by a glider stream". It will fail if there is no input stream, but otherwise the input stream is going to non-existence, and the output stream can be treated as a new stream coming from a glider gun.

But that's just an interpretation, and not something that could be proved experimentally. In the same way, I think it's impossible to have a single unique way to determine "exactly how many gliders are currently hidden, and are spending some time inside the reflector's reaction". Consequently, I think it is impossible to have a single unique way to count gliders in a closed circuit containing a dependent reflector.)

[dvgrn]

The proposed procedure doesn't work. I took a dependent reflector from the p26 glider shuttle article and added parts of input and output streams to it. The pattern below shows two copies of the result. As required, the copy on the right has one input glider removed.

Sorry, it didn't occur to me that this detail might need to be spelled out:

Advance your chosen glider to one tick before it begins to interact with the dependent reflector.

If you choose a glider that's far away from its interaction with the reflector, then it's clearly not an "input glider" to that dependent reflector during the N-tick time period that we're looking at.

[confocaloid]

The proposed procedure doesn't work. I took a dependent reflector from the p26 glider shuttle article and added parts of input and output streams to it. The pattern below shows two copies of the result. As required, the copy on the right has one input glider removed.

Sorry, it didn't occur to me that this detail might need to be spelled out:

Advance your chosen glider to one tick before it begins to interact with the dependent reflector.

If you choose a glider that's far away from its interaction with the reflector, then it's clearly not an "input glider" to that dependent reflector during the N-tick time period that we're looking at.

To be precise, one needs to define how to compute the moment of first interaction of a glider with the reflector. But suppose that the following is one tick before the interaction:

Code: Select all

x = 121, y = 31, rule = B3/S23
11b2o98b2o$11bobo97bobo$14bo2b2o95bo2b2o$12b2obo2bo93b2obo2bo$11bobob
2o94bobob2o$12bo99bo2$18bo99bo$17b2o98b2o$16b2obo96b2obo$11b2o3b3o92b
2o3b3o$10bo2bo2b5o89bo2bo2b5o$12bo3bob3o91bo3bob3o$8bo9b2o88bo9b2o$7bo
b2o96bob2o$7bo7bo5b2o84bo7bo$6b2o5b2o5b2o84b2o5b2o$14b2o6bo91b2o5$7bob
o97bobo$7b2o98b2o$8bo99bo4$2bo99bo$2o98b2o$b2o98b2o!

After running this for 26 ticks (the period of the reflector), the destruction of the reflector is already in progress. The reflector is already partially destroyed, and any internal logic that could be assumed no longer works. So it is impossible to say whether the fourth output glider on the left is "the" last input glider, or if it is the previous input glider that was allowed to leave thanks to the existence of the last input glider, or if it is the third from last input glider that was allowed to leave, and so on.
I interpret the output gliders as a new separate glider stream.

[dvgrn]

To be precise, one needs to define how to compute the moment of first interaction of a glider with the reflector.

This is another thing that's clear enough that I didn't think it was necessary to spell out. A glider's first interaction with an object is either the suppression of a birth that would ordinarily happen if the glider was traveling through empty space -- or the turning on of one or more cells neighboring the glider's usual five cells, that would not ordinarily occur if the glider was traveling through empty space.

After running this for 26 ticks (the period of the reflector), the destruction of the reflector is already in progress. The reflector is already partially destroyed, and any internal logic that could be assumed no longer works. So it is impossible to say whether the fourth output glider on the left is "the" last input glider, or if it is the previous input glider that was allowed to leave thanks to the existence of the last input glider, or if it is the third from last input glider that was allowed to leave, and so on.

If you want to state that "it's impossible to say" that, then you're no longer testing the procedure I outlined. The procedure gives a clear answer to that question: yes, the glider that is present in your pattern on the left side after 26 ticks, and is not present on the right side, is absolutely clearly the output glider for the input glider that you're testing.

Scorbie's method might make things a little clearer in this case, since we don't have to test anything to destruction that way:

Code: Select all

x = 176, y = 76, rule = LifeHistory
5.2C98.2D$5.C.C97.D.D$8.C2.2C95.D2.2D$6.2C.C2.C93.2D.D2.D$5.C.C.2C94.
D.D.2D$6.C99.D2$12.C99.D$11.2C98.2D$10.2C.C96.2D.D$5.2C3.3C92.2D3.3D$
4.C2.C2.5C89.D2.D2.5D$6.C3.C.3C91.D3.D.3D$2.C9.2C88.D9.2D$.C.2C96.D.
2D$.C13.2A84.D13.2A$2C12.2A84.2D12.2A$16.A99.A4$22.A99.A$21.2A98.2A$
21.A.A97.A.A5$28.2A98.2A$27.2A98.2A$29.A99.A4$35.A99.A$34.2A98.2A$34.
A.A97.A.A5$41.2A98.2A$40.2A98.2A$42.A99.A4$48.A99.A$47.2A98.2A$47.A.A
97.A.A5$54.2A98.2A$53.2A98.2A$55.A99.A4$61.A99.A$60.2A98.2A$60.A.A97.
A.A5$67.2A98.2A$66.2A98.2A$68.A99.A4$74.A99.A$73.2A98.2A$73.A.A97.A.A!

Ten gliders go in, ten gliders come out. There's quite clearly a one-to-one correspondence. The correspondence is clear even if you have only one glider going in, and you run it for however long is needed to get a glider out.

However, I understand how you could be worried about the general case, with signals "hiding" inside the dependent reflector. Let's see if I can make up an example --

Code: Select all

x = 44, y = 63, rule = B3/S23
2o$bo9b2o$bobo6bo2bo$2b2o7b2o2$21b2o$9b2o10bo$8bobo8bobo$9bo9b2o3$2b2o
7b3o$bobo6bo2b2o$bo9bo3bo$2o10b2obo$13b2o2$6bo$4b3o13b2o$4bobo13bobo$
4bo17bo$22b2o17$19b2o$18b2o$20bo20$42bo$41b2o$41bobo!

Two gliders go in, three gliders come out -- no one-to-one correspondence. Meaning there's an extra signal hiding in the active reaction. That shouldn't be surprising, and the problem goes away if you start the analysis where the glider first interacts with the reflector:

Code: Select all

x = 28, y = 47, rule = B3/S23
2o$bo9b2o$bobo6bo2bo$2b2o7b2o2$21b2o$21bo$19bobo$19b2o$9b3o$7b2ob2o$2b
2o11b2o$bobo7bobo$bo9bo3b2o$2o10bo2bo$13b2o3$3bobo14b2o$3b2o15bobo$4bo
17bo$22b2o$2b3o$2bo$3bo20$25b2o$25bobo$25bo!

Two gliders in, two (relevant) gliders out -- back to a clear one-to-one correspondence.

Now, I'll go ahead and build something that will have the best odds of breaking my definition if its' breakable: a dependent reaction that takes a really really long time to produce its output glider. Here goes:

Code: Select all

x = 461, y = 213, rule = B3/S23
45bo233bo$45b3o231b3o$48bo22bo210bo22bo$47b2o20b3o11bo197b2o20b3o11bo$
68bo14b3o216bo14b3o$68b2o16bo14bo200b2o16bo14bo$85b2o12b3o217b2o12b3o$
38bo59bo173bo59bo$36b3o36b4obo17b2o170b3o36b4obo17b2o$12bo2bo19bo30b3o
3bobo3b2ob2o163bo2bo19bo30b3o3bobo3b2ob2o$11bo3b2o5b2o11b2o27b5o2bobo
171bo3b2o5b2o11b2o27b5o2bobo$11bo3bo6b2o39b2o8bo5b2o16b2o146bo3bo6b2o
39b2o8bo5b2o16b2o$11bo3bo48b2o4b3o24b2o146bo3bo48b2o4b3o24b2o$12bo2bo
49bo3b2o3bo2b4o165bo2bo49bo3b2o3bo2b4o$bo12bo59b2o3bo155bo12bo59b2o3bo
$obo231bobo$obo231bobo$bo233bo2$47b2o32b2o198b2o32b2o$47b2o11b2o20bo
198b2o11b2o20bo$60bo19bo213bo19bo$61b3o16b2o213b3o16b2o$63bo20b2o211bo
20b2o$85bo233bo$82b3o231b3o$82bo233bo$22b2o232b2o$23bo233bo$20b3o26bo
204b3o26bo$20bo29bo49b2o152bo29bo49b2o$48b3o49bobo179b3o49bobo$75b2o
25bo206b2o25bo$76bo25b2o206bo25b2o$76bobo15b2o214bobo15b2o$77b2o15b2o
215b2o15b2o8$89b2o232b2o$89bob2o230bob2o$91b2o232b2o$89b2o232b2o$87b2o
6b2o224b2o6b2o$95bobo231bobo$87bobo7bo223bobo7bo$88bo8b2o223bo8b2o9$
85b2o232b2o$85b2o232b2o$73b2o232b2o$72bobo231bobo$72bo233bo$71b2o232b
2o2$96b2o232b2o$75b2o19bo212b2o19bo$76bo17bobo213bo17bobo$76bobo15b2o
214bobo15b2o$77b2o4bo227b2o4bo$82bobo231bobo$82bobo231bobo$83bo10b2o
221bo10b2o$94bobo231bobo$96bo233bo$96b2o232b2o$81b2o232b2o$82bo233bo$
79b3o231b3o$79bo233bo10$104b3o231b3o$104bo233bo$105bo233bo38$144b3o
231b3o$144bo233bo$145bo233bo38$184b3o231b3o$184bo233bo$185bo233bo36$
457bo2$224b3o231b3o$224bo233bo$225bo233bo!

This here is a nice old steampunk dependent reflector based on a Callahan G-to-H, humming along nicely at p160.

If we don't know about Herschels and consider the Silver reflector to be a mysterious black box, then we definitely don't get anything that looks like one-to-one correspondence. On the left we've got four gliders going in, seven gliders coming out -- three signals are hiding in the dependent reflector.

However, if we suppress one glider -- the last one in the lower right in this case -- and then run for as long as necessary to get the last glider out on the left-hand (unsuppressed) side, then you see the usual pattern: one glider is missing on the right that was there on the left. That's the output glider that corresponds with the suppressed input glider.

The same exact thing will turn out to be true for pretty much any of these dependent reflectors: when you suppress an input glider, one output glider won't show up that would have otherwise. This is formalizable to whatever degree of formalization is necessary.

Now, possibly I could engineer some nasty complicated collapsing pattern that "reaches ahead" when it fails and suppresses an additional glider. I can't say as I'm terribly interested in that case, though. The definition as I've outlined it gives a clear unique output glider for every input glider in every reasonable case that I can think of at the moment -- so what I'm looking for is reasonable cases where it doesn't work. I'm pretty skeptical that there are any.

We could no doubt complicate the definition to somehow exclude "dependent reflectors with sneaky telegraphs bolted on to them that shoot down extra signals when they collapse", if that case ever actually came up, or if it's even actually possible... but I think it will be pretty easy to recognize cases like that, and that's a very big step away from these dependent reflector loops that we're actually working with here.

[hotdogPi]

Should this be split into another thread? I thought this was a discovery thread, not an argument thread.

[dvgrn]

Should this be split into another thread? I thought this was a discovery thread, not an argument thread.

I'm certainly happy to move this discussion if enough people upvote hotdogPi's message. EDIT: Eh, two upvotes is probably enough -- why not? However, the title is "Oscillator Discussion Thread", and this is in fact a discussion.

Furthermore, it's a discussion about an interesting type of oscillator that might help solve the omniperiodicity problem. Seems like it could be good to understand these things clearly and have a commonly agreed-on vocabulary to deal with them.

[dvgrn]

Splitting this topic off of the Oscillator Discussion Thread, where it was probably getting way too long and making way too much noise.

I'll probably put a summary of issues and terminology in this post after some kind of consensus has been reached (if that ever happens).

EDIT: I've definitely been adjusting the proposed algorithm as the discussion continues, to try to clarify it and remove possible objections. Here's a summary of the current method of identifying the specific output glider that's uniquely associated with a given input glider in any dependent reflector.

1) In a working period-N dependent reflector, find a glider that's within N ticks of its first interaction with the dependent reflector ("interaction" as defined here). Call that glider the "input glider". Call the pattern the "INPUT PRESENT" pattern.

2) Create a copy of the working dependent reflector pattern with the input glider removed. Call this copy the "INPUT ABSENT" pattern.

3) Run the INPUT PRESENT and INPUT ABSENT variants until the first difference is seen in the dependent reflector's output stream.

4) The glider that is present in the output stream in the INPUT PRESENT pattern, but absent in the INPUT ABSENT pattern, is the unique output glider that corresponds to the chosen input glider.

If there is no difference between the two output streams, then the pattern in question is not a dependent reflector -- it might be, for example, a capped glider stream and a completely independent gun, or something along those lines.

Possible improvements
If the difference in the output stream at the point where a difference first appears is something other than one missing glider... then the likely cause is something unusual and chaotic occurring due to the collapse of the dependent reflector.

If a difficulty like this appears in some specific case, I suspect it can be resolved by comparing what happens when the chosen input glider is removed at T = 0, vs. what happens when the next input glider is removed instead, at T = N. The same chaotic collapse will occur in both cases, but it will occur at times offset by N ticks -- and a different output glider will be missing, reliably corresponding to which input glider was removed.

Counterexamples welcome! It seems clear that there's a workable formalization to be found here; most of the problem has been that I thought at first that it didn't exist, and then failed to find the right algorithm on the first couple of tries.

[dvgrn]

Here's a case from 2022 where "dependent reflector" and "loop" are used in the same post -- not quite all in a row, but if I'd known then that this would be an issue, I'd certainly have said "dependent reflector loop" to describe this p48 structure:

Code: Select all

x = 91, y = 91, rule = B3/S23
43b2ob2o3b2ob2o$42bo5bobo5bo$47b2ob2o$45bo7bo$26b2o14bo2bob2ob2obo2bo$
26b2o15bo3bo3bo3bo$35b3o6b2ob2ob2ob2o$45bo2bobo2bo$34bobobo7bobobobo$
32b2o5b2o6bo3bo$34bo3bo4$34bo3bo$21bo3bo6b2o5b2o$20bobobobo7bobobo$19b
o2bobo2bo$18b2ob2ob2ob2o6b3o33b2o$17bo3bo3bo3bo40bo2bo$16bo2bob2ob2obo
2bo40bo2bo$19bo7bo39bo6bo$21b2ob2o40bobo3bo2bo$16bo5bobo5bo36b2o3b3o$
17b2ob2o3b2ob2o$39bo27b2o3b3o$37b2o12b2o13bobo3bo2bo$38b2o10b2o15bo6bo
10b2o$52bo18bo2bo10b2o$70bo2bo$71b2o3$75bo5bo$5b2o67b3o3b3o$4bo2bo$5bo
2bo$bo6bo18bo$obo3bo2bo15b2o36b2o$b2o3b3o17b2o34b2o$64bo9b3o3b3o$b2o3b
3o66bo5bo$obo3bo2bo$bo6bo$5bo2bo75b2o$4bo2bo75bo2bo$5b2o75bo2bo$82bo6b
o$81bo2bo3bobo$9bo5bo66b3o3b2o$8b3o3b3o9bo$27b2o34b2o17b3o3b2o$26b2o
36b2o15bo2bo3bobo$63bo18bo6bo$82bo2bo$83bo2bo$8b3o3b3o67b2o$9bo5bo3$
18b2o$17bo2bo$4b2o10bo2bo18bo$4b2o10bo6bo15b2o10b2o$15bo2bo3bobo13b2o
12b2o$16b3o3b2o27bo$61b2ob2o3b2ob2o$16b3o3b2o36bo5bobo5bo$15bo2bo3bobo
40b2ob2o$16bo6bo39bo7bo$16bo2bo40bo2bob2ob2obo2bo$17bo2bo40bo3bo3bo3bo
$18b2o33b3o6b2ob2ob2ob2o$63bo2bobo2bo$52bobobo7bobobobo$50b2o5b2o6bo3b
o$52bo3bo4$52bo3bo$39bo3bo6b2o5b2o$38bobobobo7bobobo$37bo2bobo2bo$36b
2ob2ob2ob2o6b3o$35bo3bo3bo3bo15b2o$34bo2bob2ob2obo2bo14b2o$37bo7bo$39b
2ob2o$34bo5bobo5bo$35b2ob2o3b2ob2o!

Another case where a closed chain of dependent reflectors is called a loop can be found here.

These are cases where it seems unlikely that anyone would want to claim that the four glider streams are independent of each other, or that these oscillators are "not really loops". But these are dependent reflectors. If it's allowable to call the above pattern a "p48 dependent reflector loop", then why exactly would it be a good idea to avoid calling other closed chains of dependent reflectors "loops" as well?

After all of this review, it still seems very clear to me that dependent reflector loops are perfectly valid loops. They're a little trickier in some cases than independent reflector loops, but that complexity doesn't seem to be fixable with newly created terminology. Trying to define some sense in which dependent reflector loops not actually loops, or the signals in them are not actually signals, seems far more confusing than just continuing to call them what they are -- signals traveling in loops, moving information through the Life universe right in line with the definition of "signal".

Consistency Check
Here's one more minor point in favor of "dependent reflector loop" being a valid application of current standard terminology, not a neologism:

A "dependent reflector" is presumably a reflector. Reflectors reflect signals.

That says to me that if in fact we shouldn't be calling dependent reflector loops "loops", because they supposedly don't actually reflect signals, then we would also have to look at calling dependent reflectors something other than "reflectors".

Luckily dependent reflectors _are_ reflectors, they do reflect signals, and the signals do form loops -- so as far as I can tell, there isn't any actual problem with the phrase "dependent reflector loop".

[confocaloid]

I don't agree with several points in this discussion. This is an incomplete reply.

...
A "dependent reflector" is presumably a reflector. Reflectors reflect signals.
...

In general, reflectors don't reflect signals. Reflectors reflect gliders or other spaceships. Sometimes, but not always, it is useful or convenient to refer to those gliders or spaceships as signals.

My understanding is that in this case (streams of gliders moving between dependent reflectors in a closed circuit), it is confusing to refer to gliders as signals. In these oscillators, the gliders do not carry any information -- it's always "glider present" and never "glider absent". The only working way to fill the circuit with gliders is to fill it completely without "holes" (otherwise the dependent reflectors will fail). It cannot be used as an actual memory loop.

In an actual memory loop, there are many ways to fill the loop, and increasing length of the loop increases the number of possibilities.
In this case, it's always exactly one possibility: every glider must be present.

So these gliders are not signals. The pattern is not demonstrating storage of any useful or interesting information in these gliders. It is an oscillator.

It is possible to replace dependent reflectors with non-dependent reflectors and put some interesting actual signals in the loop, and transform the example into a different example pattern that would be an actual memory loop. As it is, it is just an oscillator, demonstrating that dependent reflectors work, and demonstrating how those dependent reflectors work.

You wouldn't call something like this a "glider loop", right? The "signals" are traveling much faster than lightspeed through the gun, and therefore they're not actually signals:

Code: Select all

x = 92, y = 46, rule = B3/S23
26bo6b2o$26bobo3b2o$9bo17bobo4bo$9b2o16bo2bo$2o2b2o4b2o15bobo$2o2b2o4b
3o13bobo$4b2o4b2o7bobo4bo$9b2o9b2o19bo$9bo10bo19b2o$40bobo4$27bo$28b2o
$27b2o19b2o$47b2o$49bo4$34bobo$35b2o19bo$35bo19b2o$55bobo4$42bo$43b2o$
42b2o19b2o$62b2o$64bo4$49bobo$50b2o19bo10bo$50bo19b2o9b2o$65bo4bobo7b
2o4b2o$63bobo13b3o4b2o2b2o$62bobo15b2o4b2o2b2o$61bo2bo16b2o$57bo4bobo
17bo$58b2o3bobo$57b2o6bo!

I would not call these gliders "signals" as well, for the reason I already attempted to explain above.

This oscillator is a pair of glider guns supported by each other's output streams. It is possible to replace one stream with a single block, which makes the Gosper's glider gun. The gun works in essentially the same way, but there is only the output stream and no input stream.

Somewhere in a bigger pattern, the gun could be used as a (non-dependent) inverting reflector (by either hitting or not hitting individual gliders with gliders from a perpendicular stream), so that it would be convenient/useful to refer to the gliders and "holes" as signals. However, in the given example, there are only gliders and no holes, and no signals.

Obviously I'm not very good at explaining stuff clearly. Here is a quote from the blog post "Building arbitrary Life patterns in 15 gliders":

It’s not unheard of to use some small number of gliders to create a larger number of gliders. As a rather trivial example, the Gosper Glider Gun takes 8 gliders to build, and 2 to destroy. Letting it run for longer before destruction will create more gliders. But, the gliders out of a gun like this are highly regular, and won’t encode any more novel system of construction no matter how long you let it run.

[hotdogPi]

They are definitely loops unless your definition of "loop" is "a specific 10-cell still life". They're loop-shaped, and the gliders loop around.

[confocaloid]

I think there are several different questions in the discussion.

There is a question "when it is useful or convenient to describe spaceships as "signals"?" -- see my previous post. My understanding is that things described as "signals" should carry some actual useful information with >= 2 different valid possibilities, neither of which would break the circuit. If there's only one possibility that allows the pattern to function as designed, then there are no signals.

There is a different question of how to refer to those oscillators, where some reflectors are used to redirect streams of gliders/spaceships moving in a closed circuit.

What to do with Category:Relays? The current definition of Relay sounds like an existing term that can be used: "A relay is an oscillator in which spaceships (typically gliders) travel in a loop."

They are definitely loops unless your definition of "loop" is "a specific 10-cell still life". They're loop-shaped, and the gliders loop around.

I think the word "loop" causes confusion with signal loops, which are a different kind of pattern.

[glider_rider]

My understanding is that in this case (streams of gliders moving between dependent reflectors in a closed circuit), it is confusing to refer to gliders as signals. In these oscillators, the gliders do not carry any information -- it's always "glider present" and never "glider absent". The only working way to fill the circuit with gliders is to fill it completely without "holes" (otherwise the dependent reflectors will fail). It cannot be used as an actual memory loop.

A dependent reflector can transmit information, namely, 'have we had a missing glider yet or not'. This signal is definitely much less versatile than that of an independent reflector, but that doesn't mean it transmits no information. If you remove a glider from a dependent reflector loop, it will transmit the 'we've had a missing glider' information around the loop.

For essentially the inverse of a dependent reflector, I would also argue that a one-time-turner transmits a signal, even though it's destroyed in the process.

[confocaloid]

My understanding is that in this case (streams of gliders moving between dependent reflectors in a closed circuit), it is confusing to refer to gliders as signals. In these oscillators, the gliders do not carry any information -- it's always "glider present" and never "glider absent". The only working way to fill the circuit with gliders is to fill it completely without "holes" (otherwise the dependent reflectors will fail). It cannot be used as an actual memory loop.

A dependent reflector can transmit information, namely, 'have we had a missing glider yet or not'. This signal is definitely much less versatile than that of an independent reflector, but that doesn't mean it transmits no information. If you remove a glider from a dependent reflector loop, it will transmit the 'we've had a missing glider' information around the loop.

For essentially the inverse of a dependent reflector, I would also argue that a one-time-turner transmits a signal, even though it's destroyed in the process.

An one-time turner can be used in a pattern to route a glider so that it gets in correct place at correct time. There may be other parts of the pattern to rebuild the one-time turner later, so that it can be used again. If it is otherwise convenient/useful to describe that glider as a signal moving through the pattern, then presence of the one-time turner does not change that.

I agree that a pattern with dependent reflectors could in principle be used to transmit information "have we had a missting glider yet or not". But is it common that dependent reflectors are actually used in this way? My impression is that the most common actual use for dependent reflectors is to redirect an uninterrupted stream of spaceships (and rebuilding a broken dependent reflector after destruction would be much harder than replacing it with a non-dependent reflector in the design).

[dvgrn]

I agree that a pattern with dependent reflectors could in principle be used to transmit information "have we had a missting glider yet or not". But is it common that dependent reflectors are actually used in this way?

It's certainly not at all common that dependent reflectors are deliberately destroyed, in the context of some larger pattern. The self-destruct trigger for the QuickSilver Demonoid might be one of the few existing examples. However, that is actually a completely valid example, I think.

That's not exactly the point, though! If a dependent reflector "could in principle be used" to transmit information, then do you really want to try to differentiate between the cases when it's transmitting information and when it's not? When it is transmitting information, do the gliders or other spaceships entering and exiting it suddenly count as "signals" after all, whereas otherwise we have to be careful not to call them that -- even in another pattern that's locally identical to that one?

It seems much less confusing to just get comfortable with the fact that a dependent reflector loop always has signals in it, transmitting information around its loop.

Take a close look at the existing definition of "signal" on the LifeWiki:

A signal is the movement of information through the Life universe. Signals can be carried by spaceships, fuses, drifters, or conduits...

In practice, many signals are encoded as the presence or absence of a glider (or other spaceship) at a particular point at a particular time.

This wording is very, very deliberate. It does not say "the movement of binary information", and it does not say that "all signals are encoded by the presence or absence of a [spaceship]". Information can still flow perfectly well, in cases where binary encoding is not possible.

In an actual memory loop, there are many ways to fill the loop, and increasing length of the loop increases the number of possibilities.
In this case, it's always exactly one possibility: every glider must be present.

So these gliders are not signals. The pattern is not demonstrating storage of any useful or interesting information in these gliders. It is an oscillator.

I think this quote puts a key confusion on display very well. The first paragraph is completely true -- but the second paragraph absolutely does not follow from the first, because "signal" and "bit" are not synonyms.

Just because information can't be trivially translated into an equivalent sequence of ones and zeroes, where you can remove the discrete objects encoding "1" or add the discrete objects encoding "0" and leave the pattern otherwise unchanged ... does not mean that there is no information flowing.

If you conflate "signal" with "bit", you're going to have trouble seeing why dependent-reflector signal loops are carrying signals. But the definition of "signal" doesn't say anything about bits. If you look at those oscillators in terms of the information flowing around them, it's clear that signals are moving around the loop -- even though each signal is conveying no more information to the next region of the Life universe than "I'm still here!"

Re: Relay
Separate topic: I don't think applying the word "relay" to dependent reflector loops will cause anything besides more confusion. "Relay" has an existing meaning that doesn't really overlap completely with "loop" -- and it's a much less popular term than it was two decades ago. If we brought it back for this purpose, we would pretty much be redefining it... which would amount to inventing a new term, much more than "dependent reflector loop" is a new term.

We already know what a loop is, and dependent reflector signal loops are in fact loops (according to my arguments above) -- so why not call them loops?

Relays in general denote a single object bouncing back and forth between two sides, as in "fluff relays". The definition of "relay" does mention "traveling in a loop" -- but the example given is more of a "degenerate loop" ... in fact, it's a shuttle (!). You wouldn't normally have a relay with multiple simultaneous signals in it, as far as I can tell.

[confocaloid]

I agree that a pattern with dependent reflectors could in principle be used to transmit information "have we had a missting glider yet or not". But is it common that dependent reflectors are actually used in this way?

It's certainly not at all common that dependent reflectors are deliberately destroyed, in the context of some larger pattern. The self-destruct trigger for the QuickSilver Demonoid might be one of the few existing examples. However, that is actually a completely valid example, I think.

That's not exactly the point, though! If a dependent reflector "could in principle be used" to transmit information, then do you really want to try to differentiate between the cases when it's transmitting information and when it's not? When it is transmitting information, do the gliders or other spaceships entering and exiting it suddenly count as "signals" after all, whereas otherwise we have to be careful not to call them that -- even in another pattern that's locally identical to that one?
...

Yes, I do want to differentiate between the cases when it's transmitting information and when it's not. I believe the terminology should help to understand what the pattern is (supposed to be). These oscillators that are made of dependent reflectors and glider streams are not very good as examples of signal loops -- you could not fill any of them in more than one way. It is unclear why would one want to talk about signals, when there is only one possibility in the pattern.

If gliders don't work as useful signals in the pattern, I do not want to describe the as "signals" -- that seems confusing and misleading to me.

[dvgrn]

It is unclear why would one want to talk about signals, when there is only one possibility in the pattern.

Let's see if I can make this point a little clearer, then.

The following is an oscillator, with sixteen signals traveling through a loop made out of four Snarks. No cause for argument so far:

Code: Select all

x = 140, y = 140, rule = B3/S23
45b2o$45bobo$47bo4b2o$43b4ob2o2bo2bo$43bo2bobobobob2o$46bobobobo$47b2o
bobo$51bo2$37b2o$38bo7b2o$38bobo5b2o$39b2o3$45b3o$47bo$46bo2$49b2o$49b
o9bo$50b3o7b2o$52bo6b2o7$31bo$31b2o$30bobo4$75bo$73bobo$74b2o7$16b2o$
3b2o10bobo$4bo12bo$2bo$2b5o14b2o$7bo13bo$4b3o12bobo66bobo$3bo15b2o68b
2o$3b4o82bo$b2o3bo3b2o$o2b3o4b2o$2obo$3bo$3b2o$20b2o$19b2o$11b2o8bo$
12bo$9b3o$9bo$104bo$105bo$103b3o7$34b3o$34bo$35bo$130bo$128b3o$127bo$
118bo8b2o$119b2o$118b2o$135b2o$136bo$136bob2o$128b2o4b3o2bo$128b2o3bo
3b2o$50bo82b4o$49b2o68b2o15bo$49bobo66bobo12b3o$118bo13bo$117b2o14b5o$
137bo$122bo12bo$122bobo10b2o$122b2o7$64b2o$64bobo$64bo4$107bobo$107b2o
$108bo7$79b2o6bo$78b2o7b3o$80bo9bo$89b2o2$93bo$92bo$92b3o3$99b2o$92b2o
5bobo$92b2o7bo$101b2o2$88bo$87bobob2o$87bobobobo$84b2obobobobo2bo$84bo
2bo2b2ob4o$86b2o4bo$92bobo$93b2o!

Now, let's say I want to change the size of the loop, by replacing one of the reflectors with a p59 dependent reflector, which has a different output timing than a Snark does. A little research tells me that signals move through a p59 dependent reflector 19 ticks more quickly than they do through a Snark -- or at least, that's a very useful way to interpret what they do:

Code: Select all

x = 214, y = 82, rule = LifeHistory
136.A$135.A.A$135.A.3A$132.2A.A4.A$132.A.A.ABABA$30.A103.A.A.2A4.2A$
29.A.A88.2A11.ABA4B4.A$29.A.3A87.A9.3BA2B4.BA.A$26.2A.A4.A86.A.AB5.5B
4.B.B2A$26.A.A.ABABA87.2AB.B2.7B2.4B$28.A.A.2A4.2A84.2BA15B$14.2A11.A
BA4B4.A85.B3A14B$15.A9.3BA7BA.A85.4BA14B$15.A.A6.12B2A85.4B2A10B.2BAB
$16.2A5.13B84.7BA10B3.2B2A$20.16B83.2A11B2A2B6.2A2B$19.17B83.2A11B2A
2B7.4B$18.2AB3A13B83.B3.B3A6B10.4B$17.A2BA12B.4B87.ABA8B9.4B36.2D$14.
2A.3BAB2A8B3.4B84.2B3A2B4.2A10.4B35.D.D$13.A3B2AB2A4B2A2B6.4B82.3B.3B
.B3.A12.3B37.D4.2D$13.A2B.4A5B2A2B7.4B80.4B3.B2AB3.3A10.2B33.4D.2D2.D
2.D$14.A3.2BA7B10.4B78.4B5.2A6.A11.B33.D2.B.D.A.D.2D$19.3A8B9.4B76.4B
62.BD2BADAD$17.7B4.2A10.4B74.4B64.D2BAB3A$16.3AB.2B.B3.A12.4B72.4B65.
2ABA2D2.A$15.3BA3.B2AB3.3A10.4B70.4B66.ABA.ABABA$14.3BA5.2A6.A11.4B
69.3B58.2D6.BDBA.A.2A4.2A$13.4B27.4B68.2B56.2A2.D6.BDABAD7.A$12.4B29.
4B67.B58.A2.D.DB3.3BA2B5.A.A9.D2.2D$11.4B31.4B125.A.AB2DB.9BD3.2A10.D
.D2.D$10.4B33.4B125.2AB.13BD9.D4.D.D2.D$9.4B35.4B126.2BA10B3DB8.D4.D.
D2.D$8.4B37.4B42.2D.D79.B3A14B5.5D2.D2.3D$7.4B39.4B24.D15.D3.D79.4BA
14B6.D4.D4.D$6.4B41.4B24.D9.D3.D4.D2.D75.4B2A10B.2BAB5.D4.D3.D$5.4B
43.3B25.D8.D3.3D2.D2.D29.2D41.7BA10B3.2B2A9.D.2D$4.4B62.12D5.5D.D2.D.
4D29.D.D39.2A11B2A2BD5.2A2B$3.4B73.D8.D3.D2.D4.D31.D4.2D33.2A11B2A2B
7.4B$2.A3B73.D9.D3.D2.D4.D27.4D.2D2.D2.D32.B3.B3A6B2.3D5.4B$.B2AB73.D
15.2D5.D27.D2.B.D.D.D.2D36.DABA8B2.D6.4B$BABA21.2A104.BD3BD.D38.BDC2A
2B4.2A10.4B$25.A.A104.D4B.D37.BDBD3B.B3.A12.3B$27.A4.2A99.2B.2D37.4B
3.B2AB3.3A10.2B$23.4A.2A2.A2.A96.DBD39.4B5.2A6.A11.B$23.A2.A.A.A.A.2A
87.2D6.BD2B38.4B$25.BABABA.A91.D6.B2D2BD35.4B$26.B2ABA.A91.D.DB3.6B
34.4B$27.2B.BA93.2DB.5BD3BD31.4B$26.BAB98.7BD4BD30.3B$17.2A6.B3A98.
10B3DB29.2B$18.A6.ABABAB96.15B$18.A.AB3.A3BAB98.8B2.4B$19.3A.2A5B2AB
96.6B5.4B$21.2A4BA4BAB94.9B4.4B$21.3A2BAB2A2B2AB92.5B3.2D5.4B$21.BAB
6ABA4B90.4B5.D7.4B$23.2A6B2.4B88.4B7.3D5.4B$23.BA4B5.4B86.D3B10.D6.4B
$22.9B4.4B84.B2DB19.4B$21.5B3.2A5.4B82.BDBD21.3B$20.4B5.A7.4B80.4B23.
2B$19.4B7.3A5.4B78.4B25.B$18.4B10.A6.4B76.4B$17.4B19.4B$16.3AB21.4B$
15.3BA23.4B$14.3BA25.4B$13.4B27.4B68.B$12.4B29.4B$11.4B31.4B$10.4B33.
4B$9.4B35.4B$8.4B37.4B$7.4B39.4B$6.4B41.4B$5.4B43.4B$4.4B45.4B$3.4B
47.4B$2.A3B49.4B$.B2AB51.4B$BABA53.4B!

So if I replace one Snark with one p59 dependent reflector, the loop is going to end up being the wrong length -- it won't work any more. Gliders will arrive 19 ticks too soon at their future destinations. That won't matter for the Snarks as long as all the signals get adjusted to 59 ticks apart, but it will definitely matter when they get back around the loop to the dependent reflector again!

The simplest solution is to remove one signal from the loop, and reduce the size of the loop by 5 cells. 5 cells times 8 ticks (four ticks going out, four ticks coming back) is 40 ticks, so now we've successfully subtracted 59 ticks from the length of the loop, and we have a working oscillator again:

Code: Select all

x = 135, y = 131, rule = B3/S23
50bo$49bobo$49bob3o$46b2obo4bo$46bobobobobo$48bobob2o4b2o$34b2o11bobo
8bo$35bo12bo7bobo$35bobo18b2o$36b2o$47b2o$41bo5b3ob2o$40bobo9b2o$40bo
2bo7bo$41bobo$33b2o6b3o$33b2o3$48b2o$48bo$43b2o4b3o$43b2o6bo14bo$64bob
o$32bo32b2o$32b2o$31bobo11$79bobo$80b2o$17b2o61bo$16bobo$3b2o13bo$4bo$
2bo$2b5o14b2o$7bo13bo$4b3o12bobo$3bo15b2o$3b4o$b2o3bo3b2o$o2b3o4b2o$2o
bo91bo$3bo92bo$3b2o14b2o73b3o$18b2o$20bo$11b2o$12bo$9b3o$9bo7$109bo$
110b2o13bo$33b3o73b2o12b3o$33bo88bo$34bo88bo$119bo3bo2$117bo4bo7b2o$
117bo2b3o8bo$123b2o6bob2o$118b2o3bo2bo2b3o2bo$118bo2bo2bob3o3b2o$118bo
2bobo2b6o$114b2o3b3ob2o6bo$113bobo3b4o5b3o$113bo6bobo4bo$49bo62b2o5b3o
6b5o$48b2o70b2o10bo$48bobo79bo$130b2o10$106bobo$106b2o$63b2o42bo$63bob
o$63bo9$82bo$82b3o7bo$85bo5bo$84b2o5b3o$78b2o$77b2o$79bo4$94b2o$87b2o
5bobo$87b2o7bo$96b2o2$83bo$82bobob2o$82bobobobo$79b2obobobobo2bo$79bo
2bo2b2ob4o$81b2o4bo$87bobo$88b2o!

You seem to be trying to tell me that
1) the all-Snarks oscillator has a well-defined cycle length, and it has a well-defined number of signals (sixteen) traveling through its loop; but

2) once I put in a dependent reflector, there's suddenly no loop, no well-defined cycle length, and the number of signals is now undefined.

That just doesn't match up well with my observations of fifteen signals in the new slightly smaller loop, now going through one somewhat faster replacement reflector that happens to be dependent instead of independent.

If gliders don't work as useful signals in the pattern, I do not want to describe the as "signals" -- that seems confusing and misleading to me.

That's a big "if", though. Gliders do work as useful signals in these patterns -- if you keep the loop full and keep all the signals timed correctly, the oscillator works, and otherwise it doesn't.

It seems enormously confusing to try to pretend that these gliders aren't signals when they're going through a dependent reflector, but they are signals when they're going through an independent-reflector Snark. Quite simply, that doesn't seem like a useful way to think about dependent reflectors. They're still just reflectors, with a specific limitation about the timing of the signals that you can feed into them.

[calcyman]

To me, 'dependent reflector loop' accurately describes this particular type of oscillator. The word 'signal' doesn't feature in 'dependent reflector loop', so even though I agree with confocaloid's point that these* dependent reflectors cannot reusably transmit information, I don't see why that should disqualify these oscillators from being called 'loops'.

*the overclocked Silver reflector, on the other hand, can transmit information, because there's freedom in the relative timings of gliders.

[confocaloid]

It is unclear why would one want to talk about signals, when there is only one possibility in the pattern.

Let's see if I can make this point a little clearer, then.

The following is an oscillator, with sixteen signals traveling through a loop made out of four Snarks. No cause for argument so far:

Code: Select all

rle

In the p59 loop with some gliders and four Snarks, I can manually delete one visible glider from a phase, and the period becomes 944 = 59 x 16. So I definitely agree that there are 16 gliders.

I also agree that in the first pattern (with Snarks only) the gliders are circulating in a single closed stream -- because it is easy to track (visually) movement of individual gliders, even when all 16 are present: 59 is sufficiently high, so that there is time between the moment Snark's reaction settles into a stable constellation waiting for the next input, and the moment when the next input actually arrives. I can easily see how consecutive active reactions move through the pattern, and always remain distinguishable from each other. In this case, gliders are circulating in a single closed stream.

However, I'm not sure whether it is useful to describe these 16 gliders as "signals". I think that depends on the context. If this arises as a subpattern somewhere in such a way that presence or absence of individual gliders in the loop determines evolution of the "big pattern", then I agree to describe these circulating gliders as signals. On the other hand, if there's no "big pattern" and it is just a loop of Snarks and gliders and nothing else, then I do not want to describe gliders as signals -- that would be confusing, because the gliders are just circulating without doing anything else.

Now, let's say I want to change the size of the loop, by replacing one of the reflectors with a p59 dependent reflector, which has a different output timing than a Snark does. A little research tells me that signals move through a p59 dependent reflector 19 ticks more quickly than they do through a Snark -- or at least, that's a very useful way to interpret what they do:

Code: Select all

rle

So if I replace one Snark with one p59 dependent reflector, the loop is going to end up being the wrong length -- it won't work any more. Gliders will arrive 19 ticks too soon at their future destinations. That won't matter for the Snarks as long as all the signals get adjusted to 59 ticks apart, but it will definitely matter when they get back around the loop to the dependent reflector again!

Replacing a stable reflector (Snark) with a dependent periodic reflector (p59) has the effect that timings become well-defined only modulo 59. So "19 ticks more quickly" is an incomplete description of what happens. There is something left unexplained. An equally incomplete description would be "40 ticks more slowly", and "19 ticks too soon" could as well be "40 ticks too late".

So yes,
1) I think the all-Snark oscillator does have a well-defined cycle length and a well-defined number of gliders.
2) However, once a dependent reflector is inserted, the "cycle length" and the "number of circulating gliders" are not well-defined anymore.

The question of whether it is useful to refer to these gliders as "signals" depends on the larger context.

If gliders don't work as useful signals in the pattern, I do not want to describe the as "signals" -- that seems confusing and misleading to me.

That's a big "if", though. Gliders do work as useful signals in these patterns -- if you keep the loop full and keep all the signals timed correctly, the oscillator works, and otherwise it doesn't.

It seems enormously confusing to try to pretend that these gliders aren't signals when they're going through a dependent reflector, but they are signals when they're going through an independent-reflector Snark. Quite simply, that doesn't seem like a useful way to think about dependent reflectors. They're still just reflectors, with a specific limitation about the timing of the signals that you can feed into them.

Without any bigger context, the gliders don't work as useful signals in either of these patterns.
For the all-Snarks oscillator, one could refer to a larger context, and explain how it's possible to fill the circult in many different ways and extract information from it non-destructively. One could show the same pattern filled differently, becoming an oscillator of a different period, but still working in essentially same way.

For the oscillator with p59 dependent reflectors, it is harder to imagine a bigger context. Without that, either
(a) you fill the oscillator completely, and it works as a p59 oscillator as long as you run it in a simulation program, or
(b) you fill the oscillator incompletely, and it quickly self-destructs.
For an oscillator with moving reflected glider streams, these two possibilities are very different. "Self-destruction" is not "still working in essentially the same way". To me, (b) is case of a damaged pattern that doesn't work as intended.

---
I think most of time, describing a glider as a "signal" is confusing. I think the word "signal" should be reserved for those cases that help to understand the whole big pattern.

[dvgrn]

The word 'signal' doesn't feature in 'dependent reflector loop'...

That's certainly true.

The discussion has also extended to the question of whether it's a good idea to edit out any mention of both "signals" and "loops" from the new "dependent reflector" article.

My last post above was an extended sample use of those terms in the context of dependent reflectors. I'm hoping it was reasonably comprehensible. Now... maybe we could somehow avoid using those terms while still getting the same points across... but that seems to me like an artificial exercise, likely to create confusion rather than reduce it.

*the overclocked Silver reflector, on the other hand, can transmit information, because there's freedom in the relative timings of gliders.

Yeah, I wasn't sure I wanted to dive into that particular detail. That's certainly another way that signals can travel successfully, without the simple binary presence-or-absence mechanism that confocaloid described.

Replacing a stable reflector (Snark) with a dependent periodic reflector (p59) has the effect that timings become well-defined only modulo 59. So "19 ticks more quickly" is an incomplete description of what happens. There is something left unexplained. An equally incomplete description would be "40 ticks more slowly", and "19 ticks too soon" could as well be "40 ticks too late".

Yup, once you have a dependent reflector in the loop, you don't have to think in terms of the number of signals circulating. In practice, though, it can still be very useful to think of the entire structure as a loop. It can also be useful to think in terms of signals entering and exiting a dependent reflector, for the purpose of measuring the timing of the mechanism -- relative to other reflectors, and modulo the period of the dependent reflector as you say.

Trying to "edit away" the signals-and-loops way of describing these patterns, on the grounds that there "aren't really any signals there", still seems like a misguided idea. You shouldn't have to waste time inspecting some larger context to decide whether you can call a glider a "signal" or not. I've already given my view on why the loops are perfectly valid causal loops, so I won't repeat that here -- but if they are loops, then presumably something is traveling in those loops, and "signals" seems like a good general name for those traveling things.

There's a whole folder in Golly called "Signal-Circuitry". That circuitry has been used to build all manner of things, notably hundreds of pseudo-period glider guns, that include various mechanisms that fail miserably as soon as a single glider goes missing. Regardless, it seems to me, those mechanisms are absolutely carrying signals from place to place in the Life universe, to do the work of building the final glider streams. Information is flowing, and that's the definition of a signal.

The LifeWiki documents existing usage of commonly used terms, not just terms that have been proven to be perfectly self-consistent and not capable of creating any possible confusion. "Signal" seems to me about as common a term as you can get.

[Scorbie]

I do see a loop, so I'll try to explain.
Prepare two continuous glider streams. It has a start. It has the first glider but continues indefinitely.
Shoot one continuous glider stream to a dependent relector.
The reflector will indefinitely reflect the gliders.
Don't do anything to the other.

- If we see the output gliders we have a one-to-one correspondence:
- Where the reflected glider is - vs - where the non-reflected glider is. (where the glider would have been if they weren't reflected)
- Similarly the input gliders have a trivial one-to-one correspondence.
- The gliders that are reacting with the reflector (should be 1 but I want to be general enough) correspond to the where the non-reflected gliders are.

Similarly in a glider loop-or-shuttle-whatever-it-is-called, there is a correspondence to where the glider would have been without the reflector vs where it currently is. (And it can be reacting with the reflector at current generation)

Let A be the glider stream that goes into the dependent reflector, B the glider stream that comes out of the dependent reflector, and let C be the other glider stream that just continues indefinitely without any interactions.

I can run the whole pattern for some number of ticks (e.g. T = MN ticks, a multiple of the period N of the streams/the dependent reflector).
For stream C, it is easy to see movement of individual gliders, and it is easy to see the location at time T for any specific glider that was present at time 0. In other words, individual gliders in C can be tracked.
For stream B, it is also easy to see movement of individual gliders (away from the dependent reflector).
For stream A, individual moving gliders can be tracked only as long as they don't reach the dependent reflector. Then the input glider hits the active reaction of the dependent reflector and merges with it. If we try to imagine that the input glider from stream A "spends some time inside the reflector and then comes out in stream B", then the question is how to track when and where the chosen glider comes out (i.e. what is the exact delay caused by the reflector).

~~Since what you said above is irrelevant to what I tried to explain~~[1]., I'll reformulate the "loop interpretation" as formally as possible to remove ambiguity as much as possible and to ~~persuade you that there is a well-defined notion~~ Edit: I'm not satisfied with what I came up with; I'll let you know again when I come up with something satisfying. In the meanwhile we have nice formal definitions for future work.

[1] I'm sorry about the somewhat harsh wording. I had a misunderstanding of what you were talking at the moment.

0. Prerequisites

Let us denote pattern.run(i) to be the resulting pattern when you run pattern for i generations.


1. Infinite Glider Source.

Let us define "infinite period p glider source of glider g" as a pattern that can always be advanced by p generations and be partitioned into g and the original pattern.

This can be formalized as follows:
InfiniteGliderSource(glider: g, period: p) := { pattern |
∀ i ∈ 0..p-1, pattern.run(i) ⊇ g.run(i)
and ∀ i ∈ ℕ ∪ {0}, pattern.run(i+p) = pattern.run(i) ∪ g.run(i+p)
and ∀ i ∈ ℕ ∪ {0}, pattern.run(i) ∩ g.run(i+p) = ∅
}


Edit: I think the following is a better definition of InfiniteGliderSource:
InfiniteGliderSource(glider: g, period: p) := { pattern |
∀ i ∈ ℕ ∪ {0}, pattern.run(i) ⊇ g.run(i)
and pattern.run(i) = (pattern.run(i)-g.run(i)).run(p)
}

Let us consider s, an arbitrary "infinite period p glider source of glider g".
We can trivially track glider g from s. At gen i, g becomes g.run(i).
Notice that we can also evaluate this by running both s and s.run(p) and comparing the two.
Formally, s.track(glider: g, gen: i) := if 0 <= i < p then g.run(i) else s.run(i) xor s.run(i - p)
We use this definition to extend it to other concepts later.

2. Reflectors

Let us define a dependent glider reflector as a pattern that can convert a infinite glider source to another.

Formally, period p dependent glider reflector with input glider ig and output glider og and delay d as:
GliderReflector(in: ig, out: og, delay: d, period: p) := { reflector |
∃ isrc ∈ InfiniteGliderSource(glider: ig, period: p) such that
isrc ∩ reflector = ∅
(isrc ∪ reflector).run(d) ∈ InputGliderSource(glider: og, period: p)
}
And say that r ∈ GliderReflector(in: ig, out: og, delay: d, period: p) can reflect isrc ∈ InfiniteGliderSource(glider: ig, period: p) if (isrc ∪ reflector).run(d) ∈ InputGliderSource(glider: og, period: p)

Now lets try to track the glider.

(An independent reflector is simpler to conceptualize, but this concept can be applied to dependent reflectors as well.)
Before the glider reacts with the reflector, we can track ig.
After the glider is emitted, we can track og.
Between the two events, the glider is "inside" the reflector.
These concepts maps nicely with our previous formula: s.track(glider: g, gen: i) := if 0 <= i < p then g.run(i) else s.run(i) xor s.run(i - p)
We can generalize our notion of tracking a glider with the following method.
For reflector r that reflects isrc ∈ IGS(g, p), if we let pattern := (isrc ∪ reflector) then
pattern.track(glider: g, gen: i) := assert(i >= p), pattern.run(i) xor pattern.run(i - p)

If you think about it, this definition formalizes the effect a particular glider has on the reflecting pattern.
Which goes along really well with the intuition of people identifying this as a loop.

Note: I'm not totally satisfied with the above. I'll append notes when I come up with something satisfying.

Edit: refactor

Edit: logical fallacy in 0 <= i < p, I need a better formulation.

Edit2: I think we can fix d to p for things to be cleaner.
GliderReflector(in: ig, out: og, period: p) := { reflector |
∃ isrc ∈ InfiniteGliderSource(glider: ig, period: p) such that
isrc ∩ reflector = ∅
(isrc ∪ reflector).run(p) ∈ InputGliderSource(glider: og, period: p)
}

Edit3: Or maybe even set d to 0.

This post could be generalized to any signal (that conveys information) as well.