Unbounded Binary Counter Challenge

[dvgrn]

Following up on gameoflifemaniac's questions:

Years ago calcyman built an unbounded binary counter, but the actual pattern has been lost -- or at least it's very inconvenient to get to, saved on a possibly defunct hard drive on an ancient PC in the back of a closet somewhere.)

It seems odd that we don't already have an infinite stable memory-tape mechanism that can be set up to do an unbounded binary count, out into empty space (i.e., O(log T) growth). So if someone can point out an existing mechanism that I've forgotten about, I'll be most grateful... as well as a little embarrassed, probably..

Otherwise, let's just go ahead and build a new binary counter with modern Life technology; we can probably improve quite a bit on the original.

What is the smallest TEST glider salvo, aimed at some elbow object, with the following properties?

• If there's an empty space adjacent to the elbow, the salvo produces Still Life S off to the side, plus a piece of junk in the salvo lanes that can be used to restore the elbow, and also a 180-degree return glider (traveling in the opposite direction from the salvo, on a lane that doesn't interfere with Still Life S).
• If Still Life S already exists off to the side, the salvo removes it as well as the elbow object, and sends back a return glider on a different lane. Again, gliders anywhere along this new lane must not affect Still Life S.

So Still Life S is the "1" state, on an unlimited memory tape; empty space is the "0" state. Preferably the two return glider lanes will be a reasonable distance apart -- 18hd would be nice, since that lets the return gliders be separated by Snarks. But that's not strictly necessary. Any two distinct return lanes will do.

Other mechanisms that will be needed include

• CARRY: a salvo converting the leftover junk object into a standard elbow in a new location, diagonally farther away from the salvo source. The distance must be far enough away that the TEST salvo can be repeated without affecting copies of Still Life S, either one step farther or one step closer to the glider source from this position.
• RESET: a mechanism that places a new elbow object next to position zero on the diagonal tape.

If multiple designs end up in competition, it seems like a reasonable metric for comparison would be the sum of the number of gliders in the TEST and CARRY salvos. RESET won't be a salvo per se, so no need to include it in the metric.

[gameoflifemaniac]

One important thing. If the counter counts high enough, there will be multiple separate counting signals counting at the same time, so he have to do something to delay counting until the previous is completed.

[dvgrn]

One important thing. If the counter counts high enough, there will be multiple separate counting signals counting at the same time, so he have to do something to delay counting until the previous is completed.

Not with the design I outlined -- though probably that wasn't particularly clear.

If a TEST salvo goes out to the current bit on the tape, and either sends back a CARRY signal or a RESET signal, then nothing is going to happen until that signal gets back to "home base" and triggers the appropriate action. There's no fixed-period gun at home base, precisely because of the problem you mention.

Hadn't gotten to this detail yet, but I was thinking of running the returning RESET signal through a universal regulator with a high power of two. It would slow down the operation of the binary counter, but might make it easier to see the counter in operation by setting the right step size in Golly.

I think strange things would still happen when the numbers get high enough, though -- i.e., for some value of N, it would take longer than the universal regulator's drive period to add one to 2^N-1, but much less than the drive period to add one to 2^N, or any nearby larger number. So you'd have to bump up Golly's step size every now and then, or you'd start seeing intermediate steps with incomplete calculations -- the counter would appear to decrease temporarily. You could tell the number was in mid-increment, though, because the elbow object would still be present.

Still, setting Golly to a step size of 2^N would work for a while, and it wouldn't fail in any particularly horrible way above that point.

I suppose it's technically possible to build an unbounded binary counter with a universal regulator that automatically increases its own drive period at appropriate intervals, while still staying inside an O(log T) diameter bounding box. But that requires building huge loops to hold single-channel streams that deconstruct parts of the loop and rebuild them a little bit longer, with one more semi-Snark... this might be vaguely entertaining to think about for a while, but I can't imagine it would be any fun at all to actually build it.

EDIT: Probably a better variant of the above design is that one glider always comes back from the elbow. If only that glider comes back, it means RESET; if two gliders come back, then the extra still life was present and has been deleted (but some junk was left near the elbow). Two gliders means CARRY instead of RESET.

It will take a new custom search, I guess, unless someone already has a 180-degree dirty turner that will work. But it seems like there might be a TEST salvo out there that's just four or five gliders, possibly even just three. Reshaping the junk into a new elbow farther away will probably take more than that, but we could do that with a slow salvo easily enough, so there are definitely solutions out there.

[dvgrn]

It will take a new custom search, I guess, unless someone already has a 180-degree dirty turner that will work. But it seems like there might be a TEST salvo out there that's just four or five gliders, possibly even just three.

Here's an idea that doesn't need an automated search for a clever clean toggle mechanism -- though that would certainly be nice to have! This was found with with the Seeds of Destruction Game after a few minutes of experimenting:

Code: Select all

x = 191, y = 99, rule = LifeHistory
2E108.2E$2E108.2E9$10.2E108.2E$10.2E108.2E9$20.2E108.2E$20.2E108.2E9$
23.2A5.2D101.2A5.2E$16.A6.2A5.2D94.A6.2A5.2E$15.A.A107.A.A$15.2A108.
2A7$40.2E108.2E$40.2E108.2E3$20.2A108.2A$20.2A108.2A4$5.A109.A$4.A.A
43.2E62.A.A43.2E$5.2A43.2E63.2A43.2E9$60.2E108.2E$60.2E108.2E9$60.3A
107.3A$60.A109.A$61.A109.A24$78.3A107.3A$78.A109.A$79.A109.A!
#C [[ THUMBNAIL THUMBSIZE 2 ZOOM 4 X -12 ]]

For this mechanism, the plan will have to change a little bit:

• The TEST salvo is just two gliders. One of two gliders will be returned as shown, depending on the presence or absence of a block-bit in the yellow tape to the northeast.
  ​
• The elbow in this example will be a four-object constellation, as shown.
  ​
• If a glider is returned on the left-hand (SW) lane, then there was no block-bit present.
  
  That glider is therefore the RESET signal, so it should trigger a shotgun that sends a short TOGGLE-ON salvo to push the remaining block into that location on the tape, leaving nothing behind.
  
  This will complete the toggling of that memory bit, and the counter will be successfully incremented. Then trigger the RESET mechanism and build a new starter constellation lined up with the 0 bit.
  ​
• If a glider is returned on the right-hand (NE) lane, then a block-bit was present on the tape.
  ​
  That returning glider is therefore a CARRY signal. That block bit has been successfully toggled, so the CARRY signal will just have to trigger a shotgun that sends back a PUSH salvo aimed at the two remaining boats.
  
  The PUSH salvo will remove those boats and build two boats and two blocks, one step farther away along the tape.
  
  Another two-glider TEST salvo can be sent. immediately after the PUSH salvo.
  
  The bits on the tape can probably be much closer together than 10fd, but that's a design decision that can be made after the block-placement recipe has been chosen.

This is just what showed up after a few minutes of experimenting, without running any searches, so there's bound to be something much better than this out there!

Already this design would be perfectly buildable, with a little help from slmake to figure out what glider salvos to use. But I bet someone can invent a toggle mechanism that will need a lot fewer gliders for the TEST + TOGGLE-ON + PUSH salvos -- not to mention what we'd have to do here for RESET (which would probably involve building two boats and then triggering an initial PUSH before the first TEST.)

So, okay, who has something better?

[dvgrn]

That glider is therefore the RESET signal, so it should trigger a shotgun that sends a short TOGGLE-ON salvo to push the remaining block into that location on the tape, leaving nothing behind.

Moving this design along a little bit, just in case nobody comes up with anything better:

The TOGGLE-ON salvo turns out to be fairly lucky. Six gliders (from the P2 block-move toolkit) can make a TOGGLE-ON that allows block-bits 9fd apart on the memory tape. And eight gliders are enough for a 6fd memory tape, which is pretty good I think:

Code: Select all

x = 246, y = 128, rule = LifeHistory
2A$2A8$9.2A128.2A$9.2A128.2A5$145.2A$145.2A2$18.2A$18.2A2$151.2A$151.
2A4$21.2B128.2B$12.3B5.3B4.2D113.3B5.3B4.2D$10.3BD11B2.2D111.3BD11B2.
2D$10.2BDBD11B114.2BDBD11B$10.2B2D12B114.2B2D12B$11.15B115.15B$13.12B
118.12B$14.12B118.12B7.2A$15.4B.7B118.4B.7B6.2A$14.14B116.14B$13.10B
2.4B7.2A105.10B2.4B$12.4B2.4B4.4B6.2A104.4B2.4B4.4B$11.4B4.4B4.4B110.
4B4.4B4.4B$10.4B6.4B4.4B108.4B6.4B4.4B7.2A$2.4B3.4B8.4B4.4B99.4B3.4B
8.4B4.4B6.2A$.6B.4B5.2C3.4B4.4B97.6B.4B5.2C3.4B4.4B$.10B6.2C4.4B4.4B
96.10B6.2C4.4B4.4B$.9B14.4B4.4B95.9B14.4B4.4B$.9B15.4B4.4B94.9B15.4B
4.4B$.10B15.4B4.4B7.2A84.10B15.4B4.4B7.2A$2BD4B.4B15.4B4.4B6.2A83.2BD
4B.4B15.4B4.4B6.2A$BDBD2B3.4B15.4B4.4B90.BDBD2B3.4B15.4B4.4B$2B2DB5.
4B15.4B4.4B89.2B2DB5.4B15.4B4.4B$.4B6.4B15.4B4.4B89.4B6.4B15.4B4.4B$.
3B8.4B15.4B4.4B88.3B8.4B15.4B4.4B$13.4B15.4B4.4B99.4B15.4B4.4B$14.4B
15.4B4.4B99.4B15.4B4.4B$15.4B15.4B4.4B99.4B15.4B4.4B$16.4B15.4B4.4B7.
2A90.4B15.4B4.4B$17.4B15.4B4.4B6.2A91.4B14.3C2B4.4B$18.4B15.4B4.4B99.
4B13.C.4B4.4B$19.4B15.4B4.4B99.4B13.C.4B4.4B$20.4B15.4B4.4B99.4B15.4B
4.4B$21.4B15.4B4.4B99.4B15.4B4.4B$22.4B15.4B4.4B99.4B15.4B4.4B$23.4B
15.4B4.4B99.4B15.4B4.4B$24.4B15.4B4.4B99.4B15.4B4.4B$25.4B15.4B4.4B
99.4B15.4B4.4B$26.4B15.4B4.4B99.4B15.4B4.4B$27.4B15.4B4.4B99.4B15.4B
4.4B$28.4B15.4B4.4B99.4B15.4B4.4B$29.4B15.4B4.4B99.4B15.4B4.4B$49.3C$
49.C$50.C$171.3C$171.C$172.C2$192.3C$192.C$177.3C13.C$177.C$178.C2$
62.3C$62.C$63.C10$195.3C$195.C$196.C17.3C$74.3C137.C$74.C140.C$75.C8$
84.3C$84.C$85.C5$222.3C$222.C$223.C6$91.3C21.2C$91.C22.2C$92.C23.C2$
243.3C$243.C$244.C!

Having to push only 6fd instead of 9fd will probably save at least two gliders in the PUSH salvo. So I'm inclined to go with the more elegant-looking 8G salvo, especially since it happens to be P1 slow instead of P2 slow -- no intermediate blinkers. That means the shotgun construction will be really trivial.

Anyone interested in firing up slmake and seeing how horribly expensive the PUSH salvo will have to be? It might make sense to just shoot down one boat, and turn the other boat into a block, or possibly a honeyfarm. That way slmake can start its recipe search from a simple block as usual.

Starting from a block would also make it a bit simpler to set up the RESET mechanism, because you only have to place a single block before sending a PUSH salvo (or most of it -- just make a separate PUSH1 shotgun (the two cleanup gliders for the boats) and hook it up to the main PUSH2 shotgun. Then trigger just PUSH2 after the RESET mechanism places its block in the right place.

[simsim314]

How about *WSS salvo gun that does the following:

1. If there is a SL it erases it.
2. If there isn't it creates one and self destructs.

EDIT It should be straight forward with the universal helix mechanism.

[Extrementhusiast]

Possible design inspiration using a different rule:

Code: Select all

x = 53, y = 58, rule = JVNWWE
.23C$.C21.2C$.2CD.5C5.3C2.3C.5C$.5C3.2CD3.C.C.2C.2C.2C.C$.C.D.C2.8C.
3C.3C.CD.C$.C3.C4.C.2C.C5.C.CDC2.25C$4C.6C.C2.C.4C2.C.C11.2C.2CD2C.2C
D2CDC$2C.C8.C.DC.C2.8C.6C2.C2.C2.C2.CD.CD.C$C.2C8.C2.CDC3.C.2C2.C.C4.
C2.C2.13C$C.C9.C.2C.C.CD2C.C.6C2.C2.C.DCD3.D5.D$4C7.9C.4C.2CD2C3.C.2C
2.C$2.10C.C.C3.2C.C3.C3.11C$D.B8.C.3C4.C.C3.C8.C.2C.C$2.O8.C3.C4.C.C
3.C8.3C2.C$C.C8.C3.3C2.4C2.C10.C2.C$C.C8.C3.C.C4.5C10.C2.C$3C8.C3.C.C
5.C13.C2.C7.2D$11.C3.C.7C13.C2.10C$11.2C2.2C15.3C2.C2.C.DC.DCD.C$11.
22C.C2.2C.2CD2C.2C.C$12.C4.2C11.C2.17C$12.C3.DC12.5C.2C.C2.C4.C$12.C
3.DC19.3C2.2C.3C$12.C3.DC.19C4.4C$12.C4.C.C.2C.2CD2C.2CD2C.2CD3.C$12.
C4.C.C2.C2.C.DC2.C.DC2.CD3.C$12.C4.C.17C.CD3.C$12.C4.C2.2D.3D2.D2.D2.
DC.C4.C$12.C4.C6.4C4.4C.2C3.C$12.C4.9C.C3.2C4.2C.4C$12.C4.C6.C.13C.C.
2C$12.C4.C6.3C.2C7.C2.2C.C$12.C4.C2D6.D2.C7.2C2.C.C$12.C4.10C2.C7.7C$
12.C4.C.DC2.C.DC2.C7.C$12.C4.2C.2C.2CDC.DC7.C$12.C2.12C.D6C2.C$12.C2.
C12.DC.2C.2C$12.C2.C12.DCD.C$12.C2.C13.4C$12.C2.C13.C.2C$12.C2.C13.C.
DC$12.C2.C13.4C$12.C2.C12.DC.2C$12.C2.C13.C2.C$12.C2.C13.4C$12.C2.C
13.C.2C$12.C2.C12.DCD.C$12.C2.C12.D4C$12.C2.C12.DC.2C$12.C2.C12.DC2DC
$12.C2.C13.4C$12.C2.C13.C.2C$15.C13.C.DC$14.2C13.4C$29.C.2C$29.C2.C$
29.4C!

/shameless self-promotion

[simsim314]

Here is the basic design without self destruct. It costs 6 WSS to implement the following idea:

Reading head (RH) with two states:

State1: Block -> Nothing, Nothing -> Block.
State2: Block -> Block, Nothing -> Nothing.

Empty space is triggering the conversion from State1 -> State2. To implement this we have two parts:

Part1: Always make NOT operation.
Part2: When nothing do nothing. When hit block -> convert to NOT operation.

In this example you can see the two parts. In the right you can see the expected result, and in the left the binary representation of the integer. No self destruct introduced.

Code: Select all

x = 228, y = 722, rule = B3/S23
44b2o180b2o$44b2o180b2o23$44b2o180b2o$44b2o180b2o95$44b2o180b2o$44b2o
180b2o23$44b2o180b2o$44b2o180b2o23$44b2o180b2o$44b2o180b2o119$44b2o
180b2o$44b2o180b2o23$44b2o180b2o$44b2o180b2o47$226b2o$226b2o23$44b2o$
44b2o23$44b2o$44b2o23$44b2o$44b2o23$44b2o$44b2o23$44b2o$44b2o17$7bo5bo
$6b3o3b3o$6bob2ob2obo$7b3ob3o$7b2o3b2o2$10bo33b2o$9bobo6bo25b2o$8bo3bo
4b3o$2b3o4bobo5bob2o$bo2bo5bo7b3o$4bo5bo7b3o$o3bo3b2obo6b3o$o3bo3b2obo
6b2o$4bo5bo$bobo10b2o$14bo$13bobo$14bo$14bo4$13bo$11b2ob2o2$14bobo$12b
o3bo$12bo2b2o$13b3o$13b2o29b2o$12b2o30b2o$11b3o$9bo4bo$8bo5b2o$7bobo2b
ob2o$7bo3bo2bo$8b2obo3b2o$9b2o2$11b2o$11b2o6$27b2o$18b3o5bobo$18bo2bo
6bo$18bo$18bo$19bobo8$51bo$50b3o$50bob2o$51b3o$51b3o$51b3o$51b2o2$32b
3o$31bo2bo$34bo$30bo3bo$30bo3bo$34bo$31bobo22$7bo5bo$6b3o3b3o$6bob2ob
2obo$7b3ob3o$7b2o3b2o2$10bo$9bobo6bo$8bo3bo4b3o$2b3o4bobo5bob2o$bo2bo
5bo7b3o$4bo5bo7b3o$o3bo3b2obo6b3o$o3bo3b2obo6b2o$4bo5bo$bobo10b2o$14bo
$13bobo$14bo$14bo4$13bo$11b2ob2o2$14bobo$12bo3bo$12bo2b2o$13b3o$13b2o$
12b2o$11b3o$9bo4bo$8bo5b2o$7bobo2bob2o$7bo3bo2bo$8b2obo3b2o$9b2o30b3o$
41bo2bo$11b2o28bo$11b2o28bo3bo$41bo3bo$41bo$42bobo2$35b3o$27b2o6bo2bo$
18b3o5bobo6bo$18bo2bo6bo6bo3bo$18bo16bo3bo$18bo16bo$19bobo14bobo8$51bo
$50b3o$50bob2o$51b3o$51b3o$51b3o$51b2o2$32b3o$31bo2bo$34bo$30bo3bo$30b
o3bo$34bo$31bobo24$47bo$46b3o$46bob2o$47b3o$47b2o19$43b3o$43bo2bo$43bo
$43bo3bo$43bo3bo$43bo$44bobo!

Future work Block should also trigger self destruct. Here is faster than c/2 signal propagator:

Code: Select all

x = 97, y = 223, rule = B3/S23
14$48bo4b3o$47b3o3bo2bo$40b3o3b2obo3bo$40bo2bo2b3o4bo3bo$40bo5b3o4bo$
40bo3bob3o5bobo$40bo3bob2o$40bo6b2o$41bobo8b3o$52bo2bo$47bo4bo$47bo4bo
3bo$47bo4bo3bo$52bo$47bo5bobo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47b
o2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47b
o$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo8b3o$56bo2b
o$47bo8bo$47bo8bo3bo$47bo8bo3bo$56bo$47bo9bobo$47bo$47bo2$47bo$47bo$
47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$
47bo$47bo$47bo2$47bo$47bo18b3o$47bo18bo2bo$66bo$47bo18bo$47bo19bobo$
47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$
47bo$47bo$47bo2$47bo$47bo$47bo$34b3o$34bo2bo9bo$34bo12bo$34bo12bo$35bo
bo$47bo$47bo$47bo2$47bo$20b3o24bo$22bo24bo$21bo$47bo$47bo$47bo2$47bo$
47bo$47bo2$47bo$47bo$47bo2$47bo$47bo$47bo2$41bo5bo$40b3o4bo$40bob2o3bo
$41b3o$41b3o3bo$41b3o3bo$41b2o4bo33$42bo$41b3o$40b2obo$40b3o$41b2o!

/shameless self-promotion

I guess I'm also promoting the caterloopillar technology. It's not used enough in self constructing and logical circuitry, although it shows better results or at least very competitive with the static conduits.

EDIT For completeness same functionality with slightly different recipe:

Code: Select all

x = 54, y = 101, rule = B3/S23
7bo5bo$6b3o3b3o$6bob2ob2obo$7b3ob3o$7b2o3b2o2$10bo33b2o$9bobo6bo25b2o$
8bo3bo4b3o$2b3o4bobo5bob2o$bo2bo5bo7b3o$4bo5bo7b3o$o3bo3b2obo6b3o$o3bo
3b2obo6b2o$4bo5bo$bobo10b2o$14bo$13bobo$14bo$14bo4$13bo$11b2ob2o2$14bo
bo$12bo3bo$12bo2b2o$13b3o$13b2o$12b2o$11b3o$9bo4bo$8bo5b2o$7bobo2bob2o
$7bo3bo2bo$8b2obo3b2o$9b2o$42bo$11b2o28b3o$11b2o27b2obo$40b3o$40b3o$
40b3o$41b2o$35b3o$27b2o6bo2bo$18b3o5bobo6bo$18bo2bo6bo6bo3bo$18bo16bo
3bo$18bo16bo$19bobo14bobo8$51bo$50b3o$50bob2o$51b3o$51b3o$51b3o$51b2o
2$32b3o$31bo2bo$34bo$30bo3bo$30bo3bo$34bo$31bobo9$35b3o$34bo2bo$37bo$
33bo3bo$37bo$34bobo6$43b3o$42bo2bo$45bo$41bo3bo$41bo3bo$45bo$42bobo!

[gameoflifemaniac]

Sorry for necroposting but is this project dead?

[dvgrn]

Sorry for necroposting but is this project dead?

Not dead exactly, but it was completed as part of the GPC rebuild project, in answer to one of your questions there.

Using an SQ unit is overkill for a simple binary counter, as I mentioned in the post following the linked one. We should be able to substitute the new smaller binary tape and get a significantly more compact pattern.

[gameoflifemaniac]

Using an SQ unit is overkill for a simple binary counter, as I mentioned in the post following the linked one.

I know, so will the binary counter with simsim's mechanism be completed?

Code: Select all

x = 228, y = 722, rule = B3/S23
44b2o180b2o$44b2o180b2o23$44b2o180b2o$44b2o180b2o95$44b2o180b2o$44b2o
180b2o23$44b2o180b2o$44b2o180b2o23$44b2o180b2o$44b2o180b2o119$44b2o
180b2o$44b2o180b2o23$44b2o180b2o$44b2o180b2o47$226b2o$226b2o23$44b2o$
44b2o23$44b2o$44b2o23$44b2o$44b2o23$44b2o$44b2o23$44b2o$44b2o17$7bo5bo
$6b3o3b3o$6bob2ob2obo$7b3ob3o$7b2o3b2o2$10bo33b2o$9bobo6bo25b2o$8bo3bo
4b3o$2b3o4bobo5bob2o$bo2bo5bo7b3o$4bo5bo7b3o$o3bo3b2obo6b3o$o3bo3b2obo
6b2o$4bo5bo$bobo10b2o$14bo$13bobo$14bo$14bo4$13bo$11b2ob2o2$14bobo$12b
o3bo$12bo2b2o$13b3o$13b2o29b2o$12b2o30b2o$11b3o$9bo4bo$8bo5b2o$7bobo2b
ob2o$7bo3bo2bo$8b2obo3b2o$9b2o2$11b2o$11b2o6$27b2o$18b3o5bobo$18bo2bo
6bo$18bo$18bo$19bobo8$51bo$50b3o$50bob2o$51b3o$51b3o$51b3o$51b2o2$32b
3o$31bo2bo$34bo$30bo3bo$30bo3bo$34bo$31bobo22$7bo5bo$6b3o3b3o$6bob2ob
2obo$7b3ob3o$7b2o3b2o2$10bo$9bobo6bo$8bo3bo4b3o$2b3o4bobo5bob2o$bo2bo
5bo7b3o$4bo5bo7b3o$o3bo3b2obo6b3o$o3bo3b2obo6b2o$4bo5bo$bobo10b2o$14bo
$13bobo$14bo$14bo4$13bo$11b2ob2o2$14bobo$12bo3bo$12bo2b2o$13b3o$13b2o$
12b2o$11b3o$9bo4bo$8bo5b2o$7bobo2bob2o$7bo3bo2bo$8b2obo3b2o$9b2o30b3o$
41bo2bo$11b2o28bo$11b2o28bo3bo$41bo3bo$41bo$42bobo2$35b3o$27b2o6bo2bo$
18b3o5bobo6bo$18bo2bo6bo6bo3bo$18bo16bo3bo$18bo16bo$19bobo14bobo8$51bo
$50b3o$50bob2o$51b3o$51b3o$51b3o$51b2o2$32b3o$31bo2bo$34bo$30bo3bo$30b
o3bo$34bo$31bobo24$47bo$46b3o$46bob2o$47b3o$47b2o19$43b3o$43bo2bo$43bo
$43bo3bo$43bo3bo$43bo$44bobo!

[dvgrn]

I know, so will the binary counter with simsim's mechanism be completed?

I hope so. It's a pretty cool idea -- a spaceship that flies along until it hits a "0", which it converts to a "1" while converting itself into a different spaceship, which flies along converting "1"s to "0"s until it hits another "0" and self-destructs. Not quite sure how to do that last self-destruct part, though.

[Naszvadi]

...Not quite sure how to do that last self-destruct part, though.

Conditional pushing of a complext eater at the most significant bit?

[dvgrn]

...Not quite sure how to do that last self-destruct part, though.

Conditional pushing of a complext eater at the most significant bit?

I guess that could work, but it seems complicated. I wonder if there's a way to get the self-destruct to happen right where the carry bit gets deposited. Many carry operations won't even reach the most significant bit, so if a "0" is coded as empty space, then the most significant bit doesn't even matter to the operation of the counter.

A new most significant bit will appear every time a carry operation reaches a new bit location. But maybe there's a way to build a mechanism that will do exactly the same thing at that bit location, without caring that it's going from _111111 to 1000000 instead of from (say) 100011 to 100100.

[calcyman]

Just checking -- everyone is aware of loggrow-diam.lif from jslife-oversize, yes? (I think someone more recently recreated it with p256 guns.)

[gameoflifemaniac]

Just checking -- everyone is aware of loggrow-diam.lif from jslife-oversize, yes? (I think someone more recently recreated it with p256 guns.)

Yes

[Hunting]

Even more obvious is Pattern/HashLife/logarithmic-width.mc in the Golly pattern collection.

[gameoflifemaniac]

Even more obvious is Pattern/HashLife/logarithmic-width.mc in the Golly pattern collection.

It actually is a binary counter, just inverted.

[dvgrn]

Even more obvious is Pattern/HashLife/logarithmic-width.mc in the Golly pattern collection.

It actually is a binary counter, just inverted.

That's the same pattern as loggrow-diam.lif, and it's not precisely a binary counter -- it skips a large fraction of the possible binary strings as it's counting up. See the comments in the logarithmic-width.mc pattern for the messy details.

Just checking -- everyone is aware of loggrow-diam.lif from jslife-oversize, yes? (I think someone more recently recreated it with p256 guns.)

It wasn't very recent, though it got reposted relatively recently. It was a HashLife-friendliness experiment by Gabriel Nivasch back in 2006 when Golly was new. But again, it doesn't entirely count, because it doesn't do nice simple recognizable binary counting.

Come to think of it, with simsim314's idea of a *WSS salvo gun, if the period of the gun is fixed then eventually there will be multiple increment salvos traveling at the same time, as gameoflifemaniac mentioned, and it won't actually be possible to read out a complete bitstring for each increment before the next INC operation starts.

That kind of makes a nice simple GPC-based binary counter seem preferable, where each increment will be clearly readable, and the only thing that happens when the bitstring gets really long is that it will start taking more clock ticks to complete each increment.

[gameoflifemaniac]

Come to think of it, with simsim314's idea of a *WSS salvo gun, if the period of the gun is fixed then eventually there will be multiple increment salvos traveling at the same time, as gameoflifemaniac mentioned, and it won't actually be possible to read out a complete bitstring for each increment before the next INC operation starts.

That kind of makes a nice simple GPC-based binary counter seem preferable, where each increment will be clearly readable, and the only thing that happens when the bitstring gets really long is that it will start taking more clock ticks to complete each increment.

I propose completing the self-destruction mechanism and building something that would receive a signal from the glider, which would activate the gun to build one new *WSS salvo.

[AlbertArmStain]

Sorry for necroposting but is this project dead?

Not unless we build a flyby-nary version instead (also sorry for necroposting)
I'll use Simkin's binary counter recipe just for completeness sake