Thread for basic questions

[dvgrn]

I run Windows, and I am broke and cannot really buy a new PC to run Mac or Linux or whatever. I may make a separate program, though.

Golly has everything you need to do the kind of simulations you're describing -- you just can't do it natively with a single rule table.

I'd say it's not too likely that Golly will be updated to allow more than 256 states in the near future -- it's just too convenient and efficient to be able to store the state of each cell in a lowest-level hashtile as a single byte. At least, changing that would be more of a headache than I would want to tackle, given that Golly with that modification might not perform nearly as well -- RuleLoader would presumably run out of memory quicker.

Rules that need more than 256 states seem to be relatively few and far between, anyway... and if they're complicated enough, like a rule running nine independent Life universes simultaneously, then there are way too many rule lines needed in practice and Golly can't run the rule well anyway.

For the case you mention -- states that should only become active every N ticks -- just write two separate rule tables RuleA and RuleB, plus a Lua script that switches to RuleA and runs N-1 ticks, then switches to RuleB and runs 1 tick, and repeats that until you hit Escape.

You can add support in the script for higher step sizes or other standard Golly functionality, depending on what you need. See heisenburp.lua, which does some similar kinds of event handling to allow different speeds and reset options and so on, without leaving the script.

[wildmyron]

I run Windows, and I am broke and cannot really buy a new PC to run Mac or Linux or whatever. I may make a separate program, though.

Sorry, by platform I mean CA simulator or software development environment, many of which can be used under Windows. Dave's trick with script manipulation of the rule to run for different generations may give you sufficient flexibility though. You can also write a step function in Lua, as was done for LTL briefly, prior to native Golly support. This is computationally very inefficient though because of the constant transfer of cell lists from C types to Lua and back. Better to use the rule switching technique if you can.

[Majestas32]

My Majestic Simulator in about a year I think will be able to support these

[KittyTac]

I run Windows, and I am broke and cannot really buy a new PC to run Mac or Linux or whatever. I may make a separate program, though.

Sorry, by platform I mean CA simulator or software development environment, many of which can be used under Windows. Dave's trick with script manipulation of the rule to run for different generations may give you sufficient flexibility though. You can also write a step function in Lua, as was done for LTL briefly, prior to native Golly support. This is computationally very inefficient though because of the constant transfer of cell lists from C types to Lua and back. Better to use the rule switching technique if you can.

I do not think it is possible to edit it while it is running using the rule-switch technique.

[KittyTac]

Are there more explosive than stable outer-totalistic rules?

[77topaz]

Are there more explosive than stable outer-totalistic rules?

Probably, as anything with B1 or B2 or a lot of survival conditions becomes explosive. For isotropic non-totalistic rules, I think the fraction of explosive rules would be smaller, but maybe still a majority.

[calcyman]

Apologies for the shameless self-promotion, but lifelib is designed to support any rule with <= 2^N states and a range-8 Moore neighbourhood. N is a configurable parameter that can at least go up to 64. This is how people have been able to apgsearch 23/3/257, for instance:

http://catagolue.appspot.com/census/g257b3s23/C1

You need to write a 'kernel' for your rule in C/C++, which takes a 32-by-32 grid of cells and returns the 16-by-16 centre after [between 1 and 8 generations]. Then, lifelib's boilerplate will automatically allow you to manipulate and simulate patterns on an infinite grid using either a conventional or HashLife-based algorithm.

Is it possible in rule tables to make certain states react only on generations that are a multiple of 2, 3, etc, while using one state? I want to make a very complicated CA and want to conserve the amount of states, both for faster simulation and because there is a limit of 256 states.

Are 18446744073709551616 states enough?

It's currently awkward to integrate new kernels into lifelib, so I'm working on a convenient interface to enable this.

[dvgrn]

I do not think it is possible to edit it while it is running using the rule-switch technique.

That's more or less true. I've tried writing scripts that use g.getevent() and simulate editing from inside a script, but it's too awkward to be really satisfactory.

You could certainly stop the script, edit whatever you wanted, and then restart the script, though -- just have the script use the current generation number to decide which rule to run.

[Macbi]

Is there a way to detect the period of an incoming glider? In particular I'm thinking about p4. Is there some p4 circuitry such that a signal gets sent down one of four different conduits depending on which time a glider arrives mod 4? (EDIT: p3 would be fine too)

[dvgrn]

Is there a way to detect the period of an incoming glider? In particular I'm thinking about p4. Is there some p4 circuitry such that a signal gets sent down one of four different conduits depending on which time a glider arrives mod 4? (EDIT: p3 would be fine too)

Interesting question! I don't know of anything that's been built to date. I think something could be put together using stable circuitry (plus a bunch of oscillators, of course) -- as long as the gliders entering this hypothetical "p4 differentiator" are spaced at least 78 ticks apart: we'd have to split one signal into many and then run different tests on different signal branches. Is that okay as an additional requirement?

[Macbi]

I'm trying to prove that single-channel slow salvos are universal (with a suitable "seed" still-life ). So the 78 generation separation requirement is no problem! Ideally I'd like the seed still-life to be as small as possible (population-wise), but I suspect it will be large in any case.

[dvgrn]

I'm trying to prove that single-channel slow salvos are universal (with a suitable "seed" still-life ;-) ).

Yikes. Slow single-channel... well, it's definitely doable, but the proof-of-concept I'm thinking of isn't anything I could call "small". Maybe someone else can do better.

Are there are any known safe filters for passing gliders or *WSSes at period 3, or any higher reasonable period? All the filters I can think of need some additional constraints -- the input stream doesn't really have to be strictly period 8n+4 or period 4n+2 as the definition says, but you'll run into trouble if you send a signal past with an odd instead of even parity.

I bet someone could come up with a safe filter for a passing Herschel, though -- say, a conduit that produces a dying spark that only recovers and becomes a glider if a nearby oscillator provides the right additional spark.

If the idea is just to produce three or more distinct outputs by changing the timing of the next (arbitrarily slow) glider, then could the period be a lot higher? For example, could you use gliders with timing (0, 333, 666) mod 999? Pretty sure we could manage to distinguish those with a bank of three universal regulators, and probably that's overkill but I'm not thinking of a simpler solution right now.

EDIT: If you really want p3, you could have circuitry to construct three p3s -- pulsars, let's say -- and split an incoming signal into three gliders aimed at those pulsars, in such a way that you only get a glider out if the phase is right. Otherwise the crash just makes some controllable mess or other.

Only one of the three pulsar-crashes will produce an output, and that will tell you exactly what salvos to send to all three pulsar construction sites to clean up the mess and build new pulsars (with the right timings again).

... Like I said, it's not small. But that's another possible upper bound for the problem, anyway.

[Macbi]

If the idea is just to produce three or more distinct outputs by changing the timing of the next (arbitrarily slow) glider, then could the period be a lot higher? For example, could you use gliders with timing (0, 333, 666) mod 999? Pretty sure we could manage to distinguish those with a bank of three universal regulators, and probably that's overkill but I'm not thinking of a simpler solution right now.

Yeah, it doesn't just have to be p3, there just have to be distinguishable signals for PUSH, PULL and FIRE. In fact distinguishing just two signals might be smaller, and using 1, 01 and 001 as the three instructions. I would definitely prefer a seed still-life to an oscillator though, so the oscillators have to be constructable.

[dvgrn]

In fact distinguishing just two signals might be smaller, and using 1, 01 and 001 as the three instructions. I would definitely prefer a seed still-life to an oscillator though, so everything has to be constructable.

Binary would sure be easier -- just have to rebuild a couple of blinkers, and catch and route an output R-pentomino in whichever location it shows up:

Code: Select all

x = 32, y = 9, rule = B3/S23
6bo24bo$6bo24bo$6bo24bo3$bo$b2o22b3o$obo24bo$26bo!

But then the 1 / 01 / 001 machinery will add some complexity -- not sure how to balance that.

[Macbi]

I've been messing around with filters, and I've formed the following not-too-bad solution:

Have a G-to-2G, let one of the outputs go past a blocker which kills it if it entered in phase 0. Then let that output go into another G-to-2G and have one of its outputs go past a blocker that kills it if it entered in phase 2.

Then the three entry phases 0, 2 and 4 produce 1, 2 and 3 gliders respectively, and none of them cause an explosion. The blockers are cheap to synthesise, since they only cost four gliders each (also producing an irrelevant hive).

Then I just have to work out how to route those signals into the construction machinery. But since people are building similar machinery for the reverse caber-tosser, I'll just wait for that.

[gameoflifeboy]

I'm a bit confused about something. In April 2016, Apple Bottom was trying to create a list of all rules searched on Catagolue, but he said that his list was likely incomplete. Calcyman responded that Catagolue did not keep track of such a list.

However, by February 2018, Apple Bottom announced confidently that Catagolue had 4002 searched rulestrings in its database. What changed? Is there an official list of search rulestrings now, and if so, where can I find it?

[Saka]

Is there an official list of search rulestrings now, and if so, where can I find it?

Yes
List of rules investigated on Catagolue

[gameoflifeboy]

Is there an official list of search rulestrings now, and if so, where can I find it?

Yes
List of rules investigated on Catagolue

Is there a proof that this list contains every searched rule, even those whose last search happened before the script started tracking new rulestrings on Catagolue?

[danny]

is it possible to make a reasonably sized (let's say less than 1 billion cells) pattern that puffs graham's number blocks before stopping? obviously it would take well past the end of the universe to run to completion, but it's an interesting concept. substitute graham's number for tree(3) for extra credit

[77topaz]

is it possible to make a reasonably sized (let's say less than 1 billion cells) pattern that puffs graham's number blocks before stopping? obviously it would take well past the end of the universe to run to completion, but it's an interesting concept. substitute graham's number for tree(3) for extra credit

Wouldn't the reverse caber tosser count for that? The reverse caber tosser mechanism can synthesise any arbitrarily-sized pattern (as long as it's glider-synthesisable) within a fixed, finite number of starting live cells.

[wildmyron]

is it possible to make a reasonably sized (let's say less than 1 billion cells) pattern that puffs graham's number blocks before stopping? obviously it would take well past the end of the universe to run to completion, but it's an interesting concept. substitute graham's number for tree(3) for extra credit

Wouldn't the reverse caber tosser count for that? The reverse caber tosser mechanism can synthesise any arbitrarily-sized pattern (as long as it's glider-synthesisable) within a fixed, finite number of starting live cells.

Even simpler: the starting pattern can be a block puffer and appropriately placed eater to stop the puffer.

The difficulty is with "reasonably sized". Sure, the total number of On cells in the starting configuration is only a few hundred, but no matter how you encode information in the starting pattern there is absolutely no way to represent such a pattern within a reasonably sized GoL universe.

Edit: I stand corrected. See below

[Macbi]

is it possible to make a reasonably sized (let's say less than 1 billion cells) pattern that puffs graham's number blocks before stopping? obviously it would take well past the end of the universe to run to completion, but it's an interesting concept. substitute graham's number for tree(3) for extra credit

Sure, this should be easy. The main idea is that even though Graham's Number is really really big, it's definition isn't particularly long. You can write some short computer code that (if allowed to run long enough) would eventually output Graham's Number. The same thing is true of TREE(3) or any similar number.

So if you wanted a small pattern (in terms of population and bounding boc) which eventually evolved into Graham's Number of blocks then the thing to do would be to program one of those GoL Turing Machines people have made with a program that eventually printed Graham's Number of ones to the tape. Then have a ship run down the tape checking each bit, dropping a block for every one it finds, and deleting the tape as it goes.

[AforAmpere]

For the rule Spaghetti2 (B2cei3ary4aeiry5any/S2-c3-inq4ikry5eijr6i), this ntqfind search seems to get stuck:

Code: Select all

./ntqfind p15 k1 w4 a


It is still continuing at depth 86222. I thought qfind was incapable of getting stuck like this, is that true?

EDIT, it finished at depth 121914.

[danny]

This page says that 3c/10 orthogonal spaceships have been constructed (sans caterloopillars), but the wiki says none have. Who's right?

[dvgrn]

This page says that 3c/10 orthogonal spaceships have been constructed (sans caterloopillars), but the wiki says none have. Who's right?

They're both right. The first link just says that "growing spaceships" have been constructed where the back part moves at 3c/10. If you can make a non-Caterloopillar where the front part moves at 3c/10, then you'll have an actual spaceship.

I think the first example was by David Bell, as the Treasure Trove link says, in 1992:

Code: Select all

x = 117, y = 93, rule = B3/S23
25b4o$24b6o$23boob4o17b6o$24boo21bo5bo$47bo$15bo32bo4bo$13bo3bo32boo$
12bo19boo$12bo4bo8boo3b3o$12b5o8bobb3o3boo$25bobo7boo5boo$26bo3bo5boo4bobo$
4o27bo4bo6bobo$o3bo9bo20bo8bo68boo$o11boo98booboo$bobbobboo5b3o96b4o$
6b3o6b3o96boo$bobbobboo5b3o11bo$o11boo$o3bo9bo$4o18bobo39b3o$36boo26bobo$
35boob3o19bo3boo$13boo21b5o17bo3bo$12booboo20b3o6bo10bo$13b4o27bo3bo8bo4bo$
14boo27bo13b5o$43bo4bo$43b5o$2$31b4o$31bo3bo10bo$31bo7boo4bobo$
32bobbobb4o3bobboo8boo16boo$37boo3bo5boboo6boo16boo$32bobbobb4o3bobboo$
31bo7boo4bobo$31bo3bo10bo$31b4o$2$44b5o$44bo4bo$44bo31bo$45bo3bo25boo$74bo$
45bo3bo25boo$44bo31bo$44bo4bo$44b5o$2$31b4o$31bo3bo10bo$31bo7boo4bobo$
32bobbobb4o3bobboo$37boo3bo5boboo6boo16boo$32bobbobb4o3bobboo8boo16boo$
31bo7boo4bobo$31bo3bo10bo$31b4o$2$43b5o$43bo4bo$14boo27bo13b5o$
13b4o27bo3bo8bo4bo$12booboo20b3o6bo10bo$13boo21b5o17bo3bo$35boob3o19bo3boo$
36boo26bobo$4o18bobo39b3o$o3bo9bo$o11boo$bobbobboo5b3o11bo$6b3o6b3o96boo$
bobbobboo5b3o96b4o$o11boo98booboo$o3bo9bo20bo8bo68boo$4o27bo4bo6bobo$
26bo3bo5boo4bobo$25bobo7boo5boo$12b5o8bobb3o3boo$12bo4bo8boo3b3o$12bo19boo$
13bo3bo32boo$15bo32bo4bo$47bo$24boo21bo5bo$23boob4o17b6o$24b6o$25b4o$!