This is part of a series: Testing Evolution
- Original Creature
I started with a simple creature that gives itself 1 food, and copies itself.
- Evolution Starts
After a little while (1000 generations, +- a large range), the first signs of evolution appear. Some mutant creatures cheat and give their kids more than 1 food. This doesn’t give as big of an advantage as one might expect, since most creatures won’t get a chance to reproduce a second time (they get crowded out by the next generation). But it’s significant enough that these mutants eventually out-complete the originals.
- Near-Neutral Mutations/Fitness Tradeoffs/Junk Code
By this time, another biological phenomenon appears: fitness tradeoffs. Note that in #2’s screenshot, the first code statement is garbled. It no longer does its original job, but it does absorb mutations. This probably doesn’t have a good effect overall at first, since it also has a significant bad effect. But these eventually lengthen into monstrous mutation sponges that give a significant advantage over the original. My first guess is that this doesn’t happen because it gives an immediate fitness advantage. Instead, mutations that add a random letter are probably just less likely to cause errors than mutations that delete a random letter. Due to a subtle difference between the way my simulator does mutations, and how they happen in biology, I expect that such mutation sinks will be less beneficial in actual living things. I don’t think that will prevent them from appearing. Also, it seems that what was originally called “junk code” in living things isn’t nearly as worthless as evolutionary biologists expected. Divine Creation predicts that there will be no truly function-less code in the original creatures.
- Evolution Slows to a Crawl
This is a consequence of Michael Behe’s Irreducible Complexity (AKA Richard Dawkins’ Mount Improbable). Irreducible complexity is the level of complexity at which it’s impossible to jump to the next significant improvement with only a few mutations that happen all at once. It’s the limit of evolution. The main symptom of irreducible complexity is that as the “low-hanging fruit” of small, good mutations get used up, evolution slows to almost nothing. All other possible changes are so unlikely that you can be pretty sure that they’ll never happen, even if you have billions of years. In this case, I found that the 2 main good mutations were:
– Giving the kids more food
– Turning the first command into a mutation sink (not sure if this counts as “good” enough to make those who have it take over)
Once those get used up, it seems that the next smallest change that causes a significant good effect – whatever it may be – is improbable enough that I can be pretty sure it’ll never happen.
EDIT: It turns out that although evolutionary biologists don’t talk much about evolution’s limit, they do talk and write some about how to get around that limit. Their name for the hypothetical form of evolution that’s able to create all life from a common ancestor is open-ended evolution. One organization – the Astrobiology Research Trust – has a $100,000 prize for anyone who can demonstrate an “artificial life” (probably self-copying or life-like digital systems) that evolves without any practical limit. As far as I know, nobody has yet claimed the prize.
EDIT: Due to browser glitches, I had to re-run my simulator to get this far. This screenshot is what I found the first time I ran it for this post. What probably happened was that each creature became sterile, but at least 1 of them had a huge amount of food. Without reproduction – at least in my creatures – there was no natural selection, and every creature’s code became very random.
They don’t teach you about this in grade school, but they should. It’s the main thing that happens in the long term. Near-neutral, but slightly bad mutations build up in the gene pool. Each one isn’t bad enough to eliminate itself, so natural selection doesn’t get rid of them. They’re far more common than good mutations, so the overall trend is “down, not up“. In my creatures, evolution and devolution are rather “jumpy”, in the sense that they aren’t a gradual process, but happen suddenly. I expect that the bigger and more complex the genome, the smoother each will go.
Why? In 1-line programs, a mutation that changes 1 letter may change 1% or more of the entire genome. In a 1 000 000 000-line program, a mutation that changes 1 letter changes a far smaller proportion of the code. Such small changes can still have huge effects, but they also can have no noticeable effect.
Evolutionary biologists have known about this devolution for several decades. They run into it in living things. When they find it in creatures that reproduce asexually, they call it Muller’s Ratchet, after the guy who discovered it. Here’s an example of devolution in a virus, and here’s an example of devolution in a microbe. I got both from a quick search of google scholar for “muller’s ratchet”. I’m not sure if evolutionary biologists have a name for devolution in creatures that reproduce sexually.
For anyone who decides to read up on Muller’s Ratchet, pay attention to whether the papers you’re reading are talking about simulations or experiments on actual living things. In living things, it appears to happen consistently. In evolutionary biologists’ simulations, it sometimes does, and sometimes doesn’t, depending on the exact way that the simulation was written.
Here are a couple of examples of near-neutral (from an evolutionary standpoint) but slightly bad mutations in humans:
- Foolish Mutations/Temporarily Beneficial Mutations/Short-Sighted Mutations
EDIT: These screenshots are from a third run. I may have been lucky enough to catch it at the point when these foolish mutants had almost completely taken over. It’s also possible that the creature that wasn’t dependent on an external variable had a back-mutation.
I don’t know if any of these are the correct terms, but what finally caused a mutational meltdown was a mutation that was good in the short term, but bad in the long term. It gave its host much more food, but made it dependent on an external variable. When it took over the population, every creature depended on that single variable. It was only matter of time before one of them got a mutation that set that variable to a negative number or a non-number, which made every creature’s children stillborn.
Here’s an example of a short-sighted mutation in humans:
- (Rarely) Partial Resistance to Devolution
I only ran into this after running my simulator many times.
Once in awhile, two mutations will happen that wrap much of a creature’s source code in something that keeps that chunk from being run as code, thus effectively deactivating much of the creature. In this case, the first command has largely turned into a regular expression, which is used for searching for patterns in text. I have also run into creatures that developed quote stasis, in which much or all of the first command turns into a quoted string of text suitable for running code to do something to. This does not seem to stop devolution or extinction, but I still think it’s noteworthy. These “stasis”-causing mutations have the following effects:
- Devolution slows to a crawl
In my simulator, devolution and extinction are largely caused by the buildup of random variables. When the first command in one of my creature breaks, it creates a torrent of random variables. These encapsulating mutations prevent the code that they surround from creating those variables.
- Evolution appears to slow down by a similar amount
- The creatures get far bigger than they otherwise could
- The species survives for many times as many generations as it would without code stasis
- Sometimes, though not always, the stasis will disappear on its own. It appears that this becomes harder the longer that creatures remain in stasis.
- The parts of a creature that are no longer running don’t appear to cause good mutations either
- The simulator tends to crash
I seem to run into a disproportionate number of web browser crashes when creatures develop stasis. I’m guessing that this is due to bugs in the browsers that the simulator is running in. Specifically, my guess is that the spontaneous crashes are due to the browsers reaching a limit to how many variables they can remember, and crashing when the simulator tries to set aside more. I don’t think that web browsers are designed to store so many variables that their names alone may fill gigabytes.
- Devolution slows to a crawl
- Mutational Meltdown
EDIT: Due to browser glitches, I had to re-run my simulator to get this far
If I run my simulator for long enough, this always happens. It happens so consistently that I haven’t yet bothered to finish a “run for X generations” feature. I did find early on, though, that I needed a way to tell when every creature had died out.
EDIT 2: This is from a run I did awhile later
Here’s another way that mutational meltdown can happen. Instead of the copy command breaking, the first command broke. As far as I can tell, the creatures all by chance became dependent on a single variable, but not because that variable had their food. Instead, they all needed the variable to stay the same lest the first command have an error. Then a mutant changed that variable, and all subsequent creatures couldn’t copy themselves, because the copy command never got a chance to run.
- Screenshots on this page released under a Creative Commons Attribution 4.0 International License
- “Stand Back, I’m Gonna Try Science”
I’m not sure who created it, so I don’t know who to give credit to. It’s scattered all over the web.