There are many ID’ers who complain about the AVIDA simulation, and I for the life of me can’t figure out why this is so.
Personally, I view AVIDA to be one of the best demonstrations of Intelligent Design on the planet. It, in fact, works incredibly well. Sure, there are some sideshows that people use to make it look like AVIDA is supporting Darwinian evolution. However, AVIDA is a great platform that can be used to demonstrate and apply design detection techniques.
In an old paper of mine, I described how to reformulate Irreducible Complexity into computability theory. You can read the paper for the details, or you can read a short, non-technical summary of my ideas. The basic gist of it follows.
First, in computer programming, there is the concept of a Universal computer (also called a Turing-complete computer). A Universal computer is one that can perform any computable function. All Universal computers are computationally equivalent. Now, in reality, no computer is Universal, but just like the Ideal Gas Law gives us workable conceptions for dealing with non-ideal gases, the concepts behind Universal computers give us workable conceptions for computability theory on real computers.
So, what makes a computer Universal? As I have explained in my paper, one key feature of Universal computation is the ability to perform open-ended loops. That is, the ability to have a repetition of a statement such that there is no implicit control over the number of times that the loop executes. Let me give you a few examples. If you have programmed in any programming language, you should be able to follow.
First, let’s look at a close-ended loop. A close-ended loop looks like this:
my_animals = ["dragon", "parakeet", "chicken"];
foreach(animal in my_animals) {
print "I own a ";
print animal;
}
This is a close-ended loop, because the looping structure itself (the foreach statement) limited the number of iterations. A foreach statement is a very powerful structure, but you cannot achieve universal computation with it. It is powerful, but tame.
On the other hand, an open-ended loop looks like this:
my_animals = ["dragon", "parakeet", "chicken"];
index = 0;
while(index < my_animals.length) {
animal = my_animals[index]
print "I own a ";
print animal;
index = index + 1;
}
There is much more that can go wrong with an open-ended loop. I could forget to increment my counter. I could compare against the wrong entity. I could go backwards. I might forget a comparison altogether. However, it is also much more powerful. There are many procedures that, given a base set of functions, can only be done with open-ended loops. Therefore, open-ended loops are much more prone to failure, but they are also incredibly more powerful. There are many operations which require open-ended loops.
Therefore, since any computable function can be programmed on any Universal machine, it follows that there are functions on a given Universal machine that require open-ended loops to run. That’s where things get interesting.
Open-ended loops are not just difficult – they are chaotic. Small changes do not lead to small effects. Small changes lead to dramatic effects, such that one can’t climb the hill. It takes multiple, coordinated, simultaneous changes to make a useful change, and these changes are not incrementally useful at all – usually they are disastrous. Therefore, the possibility of a mutation that generates such a change goes up exponentially with both the number of changes required, and also (though probably not exponentially) with the size of the code base.
Therefore, my paper suggests that the way to tell a biologically-designed unit is to pick it apart to find open-ended loops. An open-ended loop that contributes towards a function essentially requires a designer. The paper has some caveats about doing this in real organisms (i.e., the actual design may be located elsewhere in a generator mechanism), but this is easy enough to analyze in AVIDA, where we know where everything comes from.
AVIDA is a great system, because it is one of the few evolutionary systems that is truly Universal. Most evolutionary systems only allow close-ended loops, precisely because it leads to fewer chaotic situations. However, this also means that the parameters of the system are what are guiding the evolution, not selection. In other words, in such cases, most of the solution is already designed-in in the evolutionary simulation. However, AVIDA at least allows for the possibility for a more open-ended evolution because its language is Universal.
Because of this, given ANY AVIDA organism, it is possible to detect the designed parts. (NOTE – it is possible that there are more designed parts than given by this method – ID goes to great lengths to remove false positives, but that means that a negative can’t necessarily be counted out). If you find an open-ended loop that contributes to function, you have found a designed part of the organism.
Also of interest – each AVIDA organism does contain a designed part – the replication loop. It is, in every case I am aware of, the only functional open-ended loop in an AVIDA system. Thus, every replicating AVIDA organism shows distinct, detectable evidence of design within the organism.
There are a very few functions that AVIDA organisms evolve, but none of these functions use or require open-ended loops to accomplish. Thus, design detection is coherently demonstrated and validated in each AVIDA organism, as well as the way in which evolution works with design to accomplish biological goals. The foundational units of operation (i.e. the open-ended loops) are designed-in, and then shifted around in a parameterized evolution to apply these units to functional tasks. The theory, simulation, and experimentation of Intelligent Design all match up in AVIDA.
I’m just not sure why so few people bother to mention it.