Highlife replicators with noise?

[Tezcatlipoca]

Hi, I'm new. I'm still getting my bearings and just learing the basics. That doesn't stop my curiosity though. I'm particularly interested in application of Life like cellular automata for a model of self replicating macromolecules, the beginnings of biological evolution. Is it possible then to create replicators within highlife that reproduce themselves and also random noise each generation or some generations?

[dvgrn]

Hi, I'm new. I'm still getting my bearings and just learing the basics. That doesn't stop my curiosity though. I'm particularly interested in application of Life like cellular automata for a model of self replicating macromolecules, the beginnings of biological evolution. Is it possible then to create replicators within highlife that reproduce themselves and also random noise each generation or some generations?

Using Golly, you mean? You lose most of the hashlife-related advantages if you're stopping every generation to make random changes -- but maybe it makes more sense to use the QuickLife algorithm for your case anyway.

Certainly you could write a script that simulates HighLife with a small probability of random change to cell states -- ON to OFF, or OFF to ON, or both, within some bounding area. Probably it would be much quicker to approximate this by picking a number of cells to change (according to some distribution or other) and then flip the states of that many randomly-chosen cells inside your bounding box.

If your probability of change is low enough, you'll probably still get things that look like classical 1D Highlife replicators -- they'll just tend to accumulate junk in the middle of the line. I suppose at some point they'd be almost inevitably doomed to stop replicating, whenever key cells at the very ends of the line happens to change state.

[Tezcatlipoca]

That is very interesting as well, but I am asking after whether it's possible to design a pattern of cells, a replicator under existing Highlife rules that spawns a replicator like itself plus noise in the pattern (or better yet a slight chance of noise in the pattern) of adjacent cells around it. You see what I'm going for? The magic of biological evolution is that replication fidelity is good but not perfect. I'm finding the idea of patterns that self replicate fascinating. I guess these patterns are somewhat different... would the replicator tracking along with noise easily replicate and could it create successive replicators that also have noise then? Probably not, I guess it's more likely it would spawn an original replicator if it was able to spawn at all.

If this is not possible, is there anyone here generally interested in creating cellular automata that more closely resemble biological evolution? For instance, it seems like conceptually, life generation because of "proximity to life" could be replaced with "proximity to composing resources" somehow. Say if there were 5 states of each cell, 0 (this is the off state), 1, 2, 3, and 4. They are randomly seeded within a bounding area (but the 0 state should be more common I'm thinking). Each state has a preferred orientation for two other states (e.g. a 1 likes a 2 on it's immediate right) and when it is adjacent to a cell with a preferred orientation but this cell is not in that preferred location, it reconfigures by swapping the cell that is in the preferred position with the out of place cell that it wants there. Once in correct position cells are locked in their state (or are somewhat resistant to be separated or move together):

Code: Select all

. . . 1 3         . . . 1-2 
. . 2 . .  =>     . . 3 . . 
. . . . .         . . . . .

Could four states with each state having two relationships with other states be enough to create an "L" shape that could replicate itself? I'm unsure. I'm playing with grids a little though trying to see what might happen. Feel free to join me in speculation or to give me some education if you'd like. Thanks!

[dvgrn]

That is very interesting as well, but I am asking after whether it's possible to design a pattern of cells, a replicator under existing Highlife rules that spawns a replicator like itself plus noise in the pattern (or better yet a slight chance of noise in the pattern) of adjacent cells around it.

I see. Maybe you're not really interested in HighLife in particular, as much as CA rules that support replicators in general?

HighLife replicators are maybe a bit too brittle for what you're looking for: change any single cell in or around it and you don't get a replicator-with-noise; you inevitably end up with not-a-replicator.

In a sense the suggestion you're making seems to be at not quite the right level: you're thinking about making changes to atoms one at a time (the ON and OFF cells of HighLife) where what you want to be able to change are some kind of highly stable information-carrying groups of atoms -- something like DNA macromolecules, presumably, but unfortunately those have no equivalent in HighLife.

Theoretically someone might design a HighLife universal constructor/computer and put together logic circuitry for a huge-scale simulation. But at that point it's not really HighLife any more, it's HighLife simulating something else entirely...!

If this is not possible, is there anyone here generally interested in creating cellular automata that more closely resemble biological evolution?

One place that's definitely worth looking is the various "loop" discussions. Take the Shapeloop thread, for example -- it starts right out by saying "The interesting part about this rule that there are many successful mutations that creates a different species of loop." Copy the rule from this posting and do File > Open Clipboard in Golly, then try opening (for example) this pattern, and see what you think.

There are some mentions in the Shapeloop thread of the Other Loop Rules thread, with more interesting experimentation going on... and Golly's Patterns/Loops collection contains some of the classic loop rules, particularly EvoLoop.

[Tezcatlipoca]

That's awesome! Just the kind of thing I'm looking for. I had promised myself I would finish an important work project before I downloaded Golly and took the plunge, but I don't think I'm going to be able to hold out...

[c0b0p0]

@Tetscatlipoca: This isn't in Highlife proper, but I think it should satisfy you. It is a replicator hassled by a glider to produce a stream of gliders that hassle the replicator to produce a glider to the side of the replicator. It creates a Sierpinski triangle.

Code: Select all

x = 17, y = 4, rule = silvertail1
.G13.2G$2G14.G$2.2G$2.G!

Here is the rule table.

Code: Select all

@RULE silvertail1
@TABLE
n_states:8
neighborhood:Moore
symmetries:permute
var a={1,2,3,4,5,6,7}
var b={1,2,3,4,5,6,7}
var c={1,2,3,4,5,6,7}
var d={1,2,3,4,5,6,7}
var e={1,2,3,4,5,6,7}
var f={1,2,3,4,5,6,7}
var g={1,2,3,4,5,6,7}
var h={1,2,3,4,5,6,7}
var s={0,1,2,3,4,5,6,7}
var t={0,1,2,3,4,5,6,7}
var u={0,1,2,3,4,5,6,7}
var v={0,1,2,3,4,5,6,7}
var w={0,1,2,3,4,5,6,7}
var x={0,1,2,3,4,5,6,7}
var y={0,1,2,3,4,5,6,7}
var z={0,1,2,3,4,5,6,7}
0,1,0,0,0,0,0,0,0,2
0,1,1,1,0,0,0,0,0,2
0,1,1,1,1,0,0,0,0,2
1,1,1,0,0,0,0,0,0,2
0,2,2,2,0,0,0,0,0,3
0,2,2,2,2,2,0,0,0,3
0,2,2,2,2,2,2,2,2,3
2,2,0,0,0,0,0,0,0,3
0,3,3,0,0,0,0,0,0,4
0,4,4,0,0,0,0,0,0,5
0,4,4,4,4,0,0,0,0,5
0,4,4,4,4,4,0,0,0,5
0,4,4,4,4,4,4,4,0,5
5,5,5,0,0,0,0,0,0,6
5,5,5,5,0,0,0,0,0,6
0,5,5,5,5,5,5,5,5,6
0,5,5,5,5,5,5,5,0,6
0,5,5,5,5,5,5,0,0,6
6,6,6,0,0,0,0,0,0,7
6,6,6,6,0,0,0,0,0,7
0,6,6,6,6,6,0,0,0,7
7,7,7,0,0,0,0,0,0,1
7,7,7,7,0,0,0,0,0,1
0,7,7,7,7,0,0,0,0,1

1,s,t,u,v,w,x,y,z,0
2,s,t,u,v,w,x,y,z,0
3,s,t,u,v,w,x,y,z,0
4,s,t,u,v,w,x,y,z,0
5,s,t,u,v,w,x,y,z,0
6,s,t,u,v,w,x,y,z,0
7,s,t,u,v,w,x,y,z,0

Note: This above rule table is meant for use in Golly.

There are some mentions in the Shapeloop thread of the Other Loop Rules thread, with more interesting experimentation going on... and Golly's Patterns/Loops collection contains some of the classic loop rules, particularly EvoLoop.

I would also recommend the Evolving CA thread for discussion about evolution, although no CA has yet been produced since it would require so many states.

[Tezcatlipoca]

In a sense the suggestion you're making seems to be at not quite the right level: you're thinking about making changes to atoms one at a time (the ON and OFF cells of HighLife) where what you want to be able to change are some kind of highly stable information-carrying groups of atoms

Could you clarify this? Do you mean it's not possible or not practical to devise rules that while handling things at the individual cell level of change (I'm assuming something about how this works I guess, is it not in sequence reading from left-to-right then in rows from top-to-bottom each turn?) still preserves things as a group?

[dvgrn]

Do you mean it's not possible or not practical to devise rules that while handling things at the individual cell level of change (I'm assuming something about how this works I guess, is it not in sequence reading from left-to-right then in rows from top-to-bottom each turn?) still preserves things as a group?

Well... yes, it's hard to devise simple rules that allow both preservation of complex structures, and construction/deconstruction of those same structures. A simple neighbor-count birth and survival rule may be too simple, at least unless you build a very careful simulation on top of the lowest level, like Brice Due's metacell patterns (see Golly/Hashlife...)

"Noise" in a structured pattern in Life or HighLife tends to have bad effects at something close to the speed of light, rapidly turning a highly organized pattern into a highly random explosion.

-- Well, "highly random"? New emergent structures start to appear almost immediately of course, but they're not the kind of emergent structures that carry information -- or at least not the kind of information where you can change a little bit (no pun intended) here or there, and end up with something that codes for almost the same structure. Change just a single cell, and very likely you change either nothing or everything.

The analogy I've used a lot is that building evolvable life forms in Conway's Life or Highlife is like building robots out of subcritical masses of enriched uranium. Everything might work just as you've designed it to for a long time, until somebody builds a structure that's just a little too big, or maybe two robots happen to bump into each other accidentally... and then suddenly as like as not you have a mushroom cloud, and no recognizable structure left.

[Tezcatlipoca]

@c0b0p0 Thanks for the pattern. Very cool. It has the privilege of being the first pattern run on my machine!

[Tezcatlipoca]

this pattern

This is nuts! What's to say we wouldn't see something emergent if we ran a pattern like this fast enough and long enough. It's been getting slower and freezing on me relatively quickly. Do you happen to know any ways I can optimize the Golly environment or my machine to run this maximizing the speed, longevity, and size of bounded area (I'm sure bounding it helps with resources?) for this pattern.

[dvgrn]

What's to say we wouldn't see something emergent if we ran a pattern like this fast enough and long enough. It's been getting slower and freezing on me relatively quickly. Do you happen to know any ways I can optimize the Golly environment or my machine to run this maximizing the speed, longevity, and size of bounded area (I'm sure bounding it helps with resources?) for this pattern.

Oddly enough, Golly does much better with unbounded patterns. Boundaries are special conditions applied generation by generation in a rather ad hoc way, to an algorithm designed with an unbounded universe as a basic assumption.

There are ways to rewrite the Hashlife/RuleLoader algorithm to get the benefits of hashing in a bounded universe, but I suspect it would take pretty much a complete rewrite from the ground up... and there are lots of tricky details about bounded universes with measurements that are not a power of two, which nobody really wants to tackle at the moment.

So... right now, probably the best thing you can do is check File > Preferences > Maximum memory, and make sure it really is set to about 75% of the amount of RAM available on your machine. If Golly runs out of memory, it has to throw away perfectly good hashtiles that it then often has to do all the work of calculating again, a few ticks later.

You can try all sorts of other tricks without using Golly's bounded-universe option, like writing a little script to trim the trailing edges off of a pattern whenever it gets big enough to slow down the simulation. But I'm afraid a lot of the problem is the unavoidable complexity of the calculation.

For maybe a few billion years in Earth's early oceans, there were mostly just a lot of algae mats just sitting around and happily reproducing, before anything properly multicellular showed up -- let alone anything with bones or teeth or legs. Computing power has come a long way in the last few decades, but we don't exactly have ocean-sized CA simulators yet, or the equivalent of billion-year run times...!

[Tezcatlipoca]

Do you mean even over the long term that unbounded does better? No matter how large even this extraordinarily complex pattern that doesn't calm down expands to, it takes less memory than a bounded grid? It's hard to understand how that can be. Now that I've switched to unbounded it seems to have slowed down the more it's all spiraled out.

So just an update on how the pattern is doing, already after 30 million generations starting from a subset of the replicators you provided me I have observed "evolution" in the following ways:
- mutation of larger "eye"(cavity within replicator that has an off state), genetic drift in the population but ultimately drift or selection to fixation (little eye won out).
- selection for length of reproductive extension and sequenced orientation of buds
- evolution of programmed cell death! Initially a replicator would replicate until it happened to be destroyed by another replicator, but greater overall density could be achieved with a phenotype that spawned two replicators and then stopped and died.
- And just now I saw a pair "interface" (interlock with their extensions) then separate and start reproducing again... now that's at the least resistance to interference by another replicator. I think it could lead to something even more interesting however if there is continued selection for replicators that interface.

I just can't take my eyes of of this. It's one of the most interesting things I've ever seen. Thanks again for sharing!

[dvgrn]

Do you mean even over the long term that unbounded does better? No matter how large even this extraordinarily complex pattern that doesn't calm down expands to, it takes less memory than a bounded grid?

Not exactly... it's more that with the current (very imperfect) algorithm, Golly spends an inordinate amount of CPU time maintaining those boundaries. it doesn't have to do with memory so much as speed.

Basically if you want to maximize the amount of area-times-time that Golly can simulate -- i.e., maximize the amount of "evolution" that might happen somewhere in Golly's universe -- then you're probably better off running an unbounded grid, and maybe trimming it off at the edges every now and then. Just a general rule of thumb, not an invariable Golly Law.

[c0b0p0]

@c0b0p0 Thanks for the pattern. Very cool.

Just search for "Jelly" on the phpBB-powered search engine on this website and you will find three other rules which have replicators-with-noise in the first result.
By the way, Evoloop has by far the fastest mutation rate, but does not have "shapeloops".