Thread for basic questions

[gameoflifemaniac]

How to edit a Golly script to not resave it as a text file?

[muzik]

How to edit a Golly script to not resave it as a text file?

Have you tried saving it with the correct script file extension?

[Apple Bottom]

Here's a question regarding terminology: what do you call the totality of cells making up an oscillator, say?

I'm asking because I was looking at xp80_mlb431z1 in B3/S23-e earlier, and thought, hey, this oscillator's envelope looks a bit like a brain. And then I hesitated and wondered if "envelope" was actually the standard term.

So, is "envelope" standard? If not, what is, if anything?

[gameoflifemaniac]

How to edit a Golly script to not resave it as a text file?

Have you tried saving it with the correct script file extension?

Yes, but... LOL I don't know how the script updated! I edited the script metafier.lua to set the base and step to 35328 and 1, recpectively. I don't know how it was resaved!

[BlinkerSpawn]

How to edit a Golly script to not resave it as a text file?

Have you tried saving it with the correct script file extension?

Yes, but... LOL I don't know how the script updated! I edited the script metafier.lua to set the base and step to 35328 and 1, recpectively. I don't know how it was resaved!

Did you switch to a new Golly version after you did this?

[drc]

I want to bring up toroidalet's question again, is it possible to prove that certain shapes (besides quad-symmetric ones) aren't spaceships in any rules? For example:

Code: Select all

x = 5, y = 3, rule = B2a/S1e
2o$4bo$4bo!

[toroidalet]

I didn't actually bring up that question. I think it was wildmyron. It's possible to prove that every pattern containing 2 isolated blocks, dominoes, dots, anything that can't expand without B2a, B1e, or B1c (but expand in multiple directions when those are present) etc cannot be spaceships because those birth conditions give unstoppable lightspeed extensions when one or more of those conditions are present. (They may be spaceships in B0 rules, though.)

[dvgrn]

It's possible to prove that every pattern containing 2 isolated blocks, dominoes, dots, anything that can't expand without B2a, B1e, or B1c (but expand in multiple directions when those are present) etc cannot be spaceships because those birth conditions give unstoppable lightspeed extensions when one or more of those conditions are present. (They may be spaceships in B0 rules, though.)

And for any "certain shape" that doesn't immediately die or provably expand explosively in every rule in the range being investigated, you're pretty much stuck simulating the shape in each rule until it settles into some predictable state, and either produces or doesn't produce an offset copy of itself.

So you could find exceptional cases where something could be proved, but all the interesting cases are bound to be undecidable without an exhaustive search -- more or less by the definition of "interesting"!

[Gamedziner]

Anything with two cells has four-fold symmetry.

[calcyman]

I want to bring up toroidalet's question again, is it possible to prove that certain shapes (besides quad-symmetric ones) aren't spaceships in any rules? For example:

Code: Select all

x = 5, y = 3, rule = B2a/S1e
2o$4bo$4bo!

Yes, the huge pattern which is a GoE in every irreversible rule would work.

[toroidalet]

In general, anything with any sort of rotational symmetry cannot be a spaceship. All 2-cell patterns can be rotated 180 degrees and remain the same, so those can't be spaceships. Also anything consisting only of things like preblocks, blocks, dominoes, and dots that can't interact at all can't be ships. For example, something like this can't be a ship:

Code: Select all

x = 10, y = 5, rule = B0/S012345678
4bo$9bo$bo7bo$2o3b2o$5b2o!

(If you move the preblock 1 cell to the right, it can interact with B2n, but that's probably not a ship either.)

[praosylen]

Can anyone disprove the existence of (M,N)c/(M+N) spaceships in two-state isotropic rules where M > 3N? I believe such spaceships (including (4,1)c/5 ships) to be impossible, but I'm getting stuck at the beginning. My general line of reasoning is that the longest time for which a cell on the front corner of a pattern (based on oblique bounding rectangle, i.e.

Code: Select all

x = 14, y = 14, rule = B/S012345678
2b4o$2bo3b4o$2bo7b4o$2bo10bo$bo11bo$bo11bo$bo10bo$bo10bo$o11bo$o11bo$o
10bo$4o7bo$4b4o3bo$8b4o!

) can advance north is 3 consecutive generations:

Code: Select all

x = 5, y = 2, rule = B2ac/S
o$o2b2o!

and that subsequently it must jump one cell to the east on the next generation, and that a ship for which M > 3N would require an episode in which the corner cell would advance for 4 generations, which is impossible. But I have no idea how to set it up formally, and to handle every possible case (such as two separate "fronts" parasitizing off of each other which can move at least up to (5,1)c/6 locally but probably not globally, or cases involving B1e).

Also, apologies that this isn't exactly a "basic" question, but I didn't know where else to put it.

[M. I. Wright]

Dumb questions regarding searching:

• How are reactions like the following, used in 31c/240 tech, found?

  Code: Select all

  x = 15, y = 21, rule = B3/S23
  2o$b2o$o2$12b3o$11bo2bo$14bo$10bo3bo$10bo3bo$14bo$11bobo4$6bo$5b3o$5bo
  b2o$6b3o$6b3o$6b3o$6b2o!

  I'd say gencols, but giving it a list of literally every single possible WSS fleet to use as pattern2 seems a tad overkil..
• How can I best utilize Hersrch in trying to make a 1G->"fast salvo" conduit, say for use in a gun? Would I have to create the inserter conduits individually and use Hersrch to find connections using a similar method to the one with rectifiers here?
• How could I search for syntheses of a reaction without necessarily finding every synthesis of the end result? i.e. if I wanted a 3-glider synthesis of the following (specifically with two gliders on the left and one on the right, but that can come later):

  Code: Select all

  x = 29, y = 19, rule = B3/S23
  bo$b2o23b3o$obo23bo$21b2o4bo$21bobo$21bo11$22b3o$22bo$23bo!
  

  ...but only with that specific reaction, ie without finding all possible syntheses of the final two-block constellation.
• Is there a collection in existence of H>2G splitters sorted according to this walkthrough by dvgrn, or is it just a matter of poring through the H>G/H>2G collection and knowing which conduits fit which classification?

[drc]

This is kind of an opinion question, but what really makes a certain (non-Life) rule special (to you)?

[muzik]

This is kind of an opinion question, but what really makes a certain (non-Life) rule special (to you)?

Sufficiently exotic spaceship speeds.

[dvgrn]

How are reactions like the following, used in 31c/240 tech, found?
... I'd say gencols...

You'd be right, I think. Gencols can handle a long list of patterns as input, and you just filter the output to tell you only about the interesting cases. You can do it in different ways -- e.g., start with the list of all possible glider + *WSS collisions in that orientation, which is a pretty reasonable-sized list (that can itself be trivially generated with gencols).

And then, there's no need to get gencols to try all possible positions for the second HWSS -- you just have to specify a big enough range that there will be at least one good result among the candidate patterns. So usually you try a smallish range first, and if you don't find what you want, you expand the range and resign yourself to a longer search.

How can I best utilize Hersrch in trying to make a 1G->"fast salvo" conduit, say for use in a gun? Would I have to create the inserter conduits individually...?

Well, that's how I do it, or at least how I used to do it -- haven't run Hersrch for a while, because it's gotten so far out of date. Will really have to update data.ini at some point. There's a version of gmc_nxtman's H-to-H collection that should make that fairly easy.

It ends up being easier if you set up the inserters manually as a first step, because very often you can get a much cleaner placement that way than if you use the same inserter for everything. Some pairs of gliders can be built trivially from one side of the salvo with just a couple of NW31 inserters, but from the other side you'd have to use a much bigger Fx119, or because of other gliders in the near vicinity sometimes even those won't work.

Once you have the inserters where you want them, just aim gliders to trigger the inserters from sufficiently far away, and adjust the gliders' positions until you get the exact output salvo that you want.

-- It's a lot easier that way than working with Herschels, though you can certainly do that if you want to. In the end you'd get smaller circuitry on average if you allow for the option of retaining the Herschel signal. But most of the time the optimal solution will probably be to produce a glider and run it through a Snark or two and then a syringe... I bet a direct Herschel connection won't save much space, on average.

How could I search for syntheses of a reaction without necessarily finding every synthesis of the end result?

The best method so far seems to be chris_c's popseq script. Your first step is gencols again, this time starting with two-glider collisions and adding a third glider with a reasonable range of offsets, wherever you want it coming from. Then you run popseq on the resulting gencols output file -- putting in the population sequence for the tail end of the desired reaction -- and, well, cross your fingers and hope.

Code: Select all

x = 5, y = 5, rule = B3/S23
3bo$3b2o$obobo$o2bo$bobo!

10, 11, 12, 10, 13, 11, 18, 12, 15, 12, 17, 15, 14, 17, 16, 18, 19, 26, 16, 17, 15, 16, 10, 15, 10, 10, 8, 8, 8, 8...

(Double-check that, don't take my word for it.) But maybe start with the first "18", or even the second one, in case the population count is obscured by dying sparks for a while.

There are going to be much faster ways to do this eventually, maybe by searching through large pre-generated text files that record hash values for each generation of each collision -- instead of population values, which allow for a lot more false positives.

Is there a collection in existence of H>2G splitters sorted according to this walkthrough by dvgrn, or is it just a matter of poring through the H>G/H>2G collection and knowing which conduits fit which classification?[/list]

No, there's a separate thread for that, with a classifer script and the beginnings of a labeled collection with at least one representative of each type. Sorry, the link was in the previous post, but not in the actual walkthrough message. I've made some edits to bring the walkthrough closer to up-to-date.

Someone needs to update the H-to-2G collection, and then classify every H-to-2G in the collection and build a much bigger and better stamp collection. It's on my list, but there are still a dozen or so items higher on the priority list... including the faster "hashseq" search idea mentioned above!

[M. I. Wright]

Thanks SO much! Kind of embarrassing on my part that I didn't find the answers to the last two questions on my own (especially with all the time I've spent on first page of the gencols:techniques thread these last two days... and biggiemac even asks my exact question a few posts up from chris_c's on page 2!) but it's great to have all this info as a starting point Thank you for the links.

popseq.py, on that note, looks like it will be especially useful; I spent yesterday & today figuring out how to most effectively use gencols to find what I want with the intention of searching through the results by hand, so it looks like all I'll have to do is run the script on my extant output files. And regarding the HWSS salvo, I guess I was thinking about the problem the wrong way, because searching for collisions of a third *WSS with enumerated-in-advance G+*WSS collisions sounds like a much saner way of going about it.
EDIT: Well, that was disappointing. No results save this:

Code: Select all

x = 21, y = 12, rule = Life
11b2o6b2o$10bobo5b2o$12bo7bo7$2o$b2o$o!

...which produces the final 8 generations flawlessly, but in the wrong orientation and after the point where the reaction is actually useful. Sucks

Is it a significant issue that gencols often produces time-offset or mirrored duplicates in its output? Part of what I did to prepare the inputs for a 3g-collision search was prune all of these duplicates (which were, funnily enough, produced by the 2g.col enumeration command in the Examples file) and then sync up the remaining contenders so that their first collision occurred at exactly the same gen, but I'm wondering if I should save the effort in the future.

————————————————————————————————

EDIT: Here are the duplicate-free 90deg 2G collisions. All synced so that their first collision happens at generation 8 (where 'collision' is defined as 'generation wherein a cell has neighbors in both pattern 1 and pattern 2'), and sorted by length of resulting reaction:
-tc 8 21

Code: Select all

.........**!........**!.**.......*!*.*!..*
**!.**!*!........**!.......**!.........*
**.......**!.**.....**!*.........*
***!..*!.*!........***!........*!.........*
......***!......*!.......*!!**!.**!*
**!.**.....***!*.......*!.........*
.........*!**......**!.**.....*.*!*
**!.**!*........*!........**!........*.*
.**!*.*!..*!!........***!........*!.........*
.........**!........**!**........*!.**!*
.........**!**......**!.**.......*!*
**!.**!*!........***!........*!.........*
.........**!........**!..........*!.**!*.*!..*
.........**!.**.....**!*.*.......*!..*
.........**!.*......**!.**.......*!*.*
.........**!........**!***.......*!..*!.*
.........*!........**!........*.*!!.**!*.*!..*

-tc 8 35

Code: Select all

**......**!.**....**!*........*
.**!*.*!..*!!........**!........*.*!........*
........***!........*!.........*!.**!*.*!..*
.**!*.*!..*!.........**!........**!..........*
***!..*!.*!!......**!......*.*!......*
.......**!.......*.*!.......*!!.*!.**!*.*
.*!.**!*.*!.........**!........**!..........*
.*.......**!.**.....**!*.*.......*
.*!.**!*.*......**!........**!..........*
***!..*......**!.*......**!..........*
***!..*!.*!!.......**!.......*.*!.......*

-tc 8 76

Code: Select all

**!.**.....**!*......**!.........*
**!.**!*.......**!.......**!.........*
........***!........*!**.......*!.**!*
.**!*.*!..*......**!........**!..........*
.**!*.*......**!..*.....**!..........*

-tc 8 102

Code: Select all

.**......**!*.*.....**!..*.......*

-tc 8 193

Code: Select all

.......***!.......*!........*!!***!..*!.*
***!..*!.*!........*!.......**!.......*.*
**......***!.**.....*!*........*!

-tc 8 541

Code: Select all

.........*!........**!........*.*!!***!..*!.*

As RLE:
-tc 8 21

Code: Select all

#C <21 gens
x = 11, y = 344, rule = B3/S23
9b2o$8b2o$b2o7bo$obo$2bo17$2o$b2o$o$8b2o$7b2o$9bo17$2o7b2o$b2o5b2o$o9b
o17$3o$2bo$bo$8b3o$8bo$9bo17$6b3o$6bo$7bo2$2o$b2o$o17$2o$b2o5b3o$o7bo$
9bo17$9bo$2o6b2o$b2o5bobo$o17$2o$b2o$o8bo$8b2o$8bobo17$b2o$obo$2bo2$8b
3o$8bo$9bo17$9b2o$8b2o$2o8bo$b2o$o17$9b2o$2o6b2o$b2o7bo$o17$2o$b2o$o$
8b3o$8bo$9bo17$9b2o$8b2o$10bo$b2o$obo$2bo17$9b2o$b2o5b2o$obo7bo$2bo17$
9b2o$bo6b2o$b2o7bo$obo17$9b2o$8b2o$3o7bo$2bo$bo17$9bo$8b2o$8bobo2$b2o$
obo$2bo!

-tc 8 35

Code: Select all

#C 23–35 gens inclusive
x = 11, y = 221, rule = B3/S23
2o6b2o$b2o4b2o$o8bo17$b2o$obo$2bo2$8b2o$8bobo$8bo17$8b3o$8bo$9bo$b2o$o
bo$2bo17$b2o$obo$2bo$9b2o$8b2o$10bo17$3o$2bo$bo2$6b2o$6bobo$6bo17$7b2o
$7bobo$7bo2$bo$b2o$obo17$bo$b2o$obo$9b2o$8b2o$10bo17$bo7b2o$b2o5b2o$ob
o7bo17$bo$b2o$obo6b2o$8b2o$10bo17$3o$2bo6b2o$bo6b2o$10bo17$3o$2bo$bo2$
7b2o$7bobo$7bo!

-tc 8 76

Code: Select all

#C 37–76 gens
x = 11, y = 87, rule = B3/S23
2o$b2o5b2o$o6b2o$9bo17$2o$b2o$o7b2o$7b2o$9bo17$8b3o$8bo$2o7bo$b2o$o17$
b2o$obo$2bo6b2o$8b2o$10bo17$b2o$obo6b2o$2bo5b2o$10bo!

-tc 8 102

Code: Select all

#C 102 gens
x = 11, y = 3, rule = B3/S23
b2o6b2o$obo5b2o$2bo7bo!

-tc 8 193

Code: Select all

#C 159–193 gens
x = 11, y = 48, rule = B3/S23
7b3o$7bo$8bo2$3o$2bo$bo17$3o$2bo$bo$8bo$7b2o$7bobo17$2o6b3o$b2o5bo$o8b
o!

-tc 8 541

Code: Select all

#C 541 gens
x = 11, y = 7, rule = B3/S23
9bo$8b2o$8bobo2$3o$2bo$bo!

And here's a quick series of version-agnostic Python regexes to turn the above RLEs into .list files:

Code: Select all

import re

try:
    input = raw_input
except NameError:
    pass

print('Enter RLE:')
rle = ''.join(iter(raw_input, ""))

# remove header and newlines
rle = re.sub('.*(B3/S23|Life)', '', rle)[:-1]

# string replacements: #

# newlines
rle = re.sub(r'([0-9]+[0-9]|[4-9])\$', '\n', rle)

# runs of dots/stars
rle = re.sub('([0-9]+)([ob])', lambda m: '*.'[m[0] == 'b'] * int(m[1]), rle)

# single dots/stars
rle = re.sub('(?<![0-9])[ob]', lambda m: '*.'[m[0] == 'b'], rle)

# exclamation points
rle = re.sub(r'([0-3]*)\$', lambda m: '!' * int(m[1] or 1), rle)

print(rle)

[dvgrn]

Is it a significant issue that gencols often produces time-offset or mirrored duplicates in its output? Part of what I did to prepare the inputs for a 3g-collision search was prune all of these duplicates (which were, funnily enough, produced by the 2g.col enumeration command in the Examples file) and then sync up the remaining contenders so that their first collision occurred at exactly the same gen, but I'm wondering if I should save the effort in the future.

Yeah, biggiemac also reported duplicates. It would be good to go back to the gencols:techniques thread and track down why the 2g.col example is producing those extra collisions. It might be easiest to publish a 2g90degree.col and 2g180degree.col that has just one instance of each collision.

In the long run I'd really like to do something similar for three-glider collisions. I'm imagining a GitHub site with a a script checked in that produces a lot of 3gcol output files -- and then maybe the results of running something like popseq on each of the output files, plus a script to do a really fast text search through those files.

I've been thinking of this vaporware search package as "hashseq". Will probably use multiple bytes per tick to record a hash value for each arrangement of cells. Will have to do some experimenting to see how many bytes are needed to avoid too many false positives. Usually knowing the whole sequence of hashes (until the pattern becomes stable) would be enough to prevent collisions, even if we had only one or two base36 digits let's say. But that won't work so well if we get ambitious and try to find a specific active reaction just one or two ticks before it settles. Will probably want to invest four bytes per tick or so, for the precomputed hashseq tables.

Also not sure yet whether to hash the apgcode standard orientation for each tick, so that it's not necessary to search eight times for different possible orientations of the same reaction. That would be useful when you don't care which direction the gliders are coming from, but would be annoying when you're searching a specific set of collisions to find a spark-or-something that fits into a larger recipe. I guess it's probably better to include an option in the search script that generates the hashseqs for all eight orientations, and returns any matching results.

[muzik]

Are there any outer-totalistic rules which are both self-inverse and simulate a Margolus block cellular automaton using 2x2 blocks?

[drc]

Are there any outer-totalistic rules which are both self-inverse and simulate a Margolus block cellular automaton using 2x2 blocks?

2x2 might be, but only with 2x2 blocks:

Code: Select all

#C [[ GPS 1 ]]
x = 32, y = 14, rule = B36/S125
18b14o$18b14o$2o2b2o12b4o2b2o2b4o$2o2b2o12b4o2b2o2b4o$2o2b2o12b4o2b2o
2b4o$2o2b2o12b4o2b2o2b4o$2o2b2o12b4o2b2o2b4o$2o2b2o12b4o2b2o2b4o$2o2b
2o12b4o2b2o2b4o$2o2b2o12b4o2b2o2b4o$2o2b2o12b4o2b2o2b4o$2o2b2o12b4o2b
2o2b4o$18b14o$18b14o!

You probably meant self-inverse altogether, though.

[Apple Bottom]

Are there any outer-totalistic rules which are both self-inverse and simulate a Margolus block cellular automaton using 2x2 blocks?

You previously asked about what Life-like CAs simulate Margolus neighborhood CAs, and I suggested you tackle this problem yourself -- did you make any progress on that?

If so, you could simply compare the lists of Life-like CAs simulating Margolus neighborhood CAs and self-complementary Life-like CAs respectively, and see if any rulestrings appear on both lists.

[muzik]

You previously asked about what Life-like CAs simulate Margolus neighborhood CAs, and I suggested you tackle this problem yourself -- did you make any progress on that?

If so, you could simply compare the lists of Life-like CAs simulating Margolus neighborhood CAs and self-complementary Life-like CAs respectively, and see if any rulestrings appear on both lists.

Every rule from B3i/S5i to B1e2-a34-w5-a678/S0123-a4-q56-a7e has the margolus behaviour, but that's only the familiar rule found in 2x2, and doesn't account for the rest of them. So a microscopic amount of progress.


EDIT: I'm going to make the assumption that there are 2^6 different margolus rules that can be simulated.

[praosylen]

Are there any outer-totalistic rules which are both self-inverse and simulate a Margolus block cellular automaton using 2x2 blocks?

It is straightforward to show that this is impossible. In order to for a pattern to remain composed of 2x2 blocks, the B3i/S5i and B4w/S4q transition pairs must each be either both present or both absent. Since each is also a pair of inverse transitions, this contradicts the fact that, in a self-inverse rule, exactly one of every inverse-transition pair must be present.

Too grammatical; didn't read: In every 2x2-like rule, any pattern containing a B3i, S5i, B4w, or S4q configuration will evolve differently when inverted.

[muzik]

Close enough, I guess:

Code: Select all

x = 37, y = 20, rule = B/S012345678
2b2o2b10o5b2o2b2o$2b2o2b10o5b2o2b2o$2b2o4b2o4b2o5b2o2b4o2b4o$2b2o4b2o
4b2o5b2o2b4o2b4o$2o2b2o2b2o13b2o2b2o2b6o$2o2b2o2b2o13b2o2b2o2b6o$2o4b
2o2b4o9b4o2b2o4b2o$2o4b2o2b4o9b4o2b2o4b2o$2b6o2b2o2b2o5b2o6b2o2b2o$2b
6o2b2o2b2o5b2o6b2o2b2o$4b2o2b2o2b4o5b4o2b2o2b2o$4b2o2b2o2b4o5b4o2b2o2b
2o$4o2b4o2b4o9b2o4b2o$4o2b4o2b4o9b2o4b2o$2o2b2o6b4o7b2o2b6o$2o2b2o6b4o
7b2o2b6o$2o4b8o9b4o8b2o$2o4b8o9b4o8b2o$2b4o4b2o2b2o5b2o4b4o2b2o$2b4o4b
2o2b2o5b2o4b4o2b2o!

As to not make this post completely pointless: Could a similar concept be applied to triangular neighbourhoods, where patterns can be made from larger triangles each made of 4 triangles?

[drc]

I have a question of my own: How many cells does it take for generation 1 to be different across every isotropic rule? outer-totalistic? asymmetric (MAP)?

A better way to phrase this is: how many cells does it take for every transition to be used in each of those rulespaces?