## Critique of Chaitin’s algorithmic mutation

July 8, 2012 4 Comments

Last week, I reviewed Gregory Chaitin’s Proving Darwin. I concentrated on a broad overview of the book and metabiology, and did not touch on the mathematical details; This post will start touching. The goal is to summarize Chaitin’s ideas more rigorously and to address Chaitin’s comment:

I disagree with your characterization of algorithmic mutations as directed.

They are in fact random.

Rgds,

GJC

Specifically, I need to (a) summarize the mathematical details of algorithmic mutations, (b) clarify the distinction between *random mutation* and (what I called) *randomized directed mutation*, and (c) defend my assertion that algorithmic mutations are not purely random but directed. I need to fully explain my earlier claim:

The algorithmic mutation actually combine the act of mutating and selecting into one step, it is a -bit program that takes the current organism A and outputs a new organism B of higher fitness (note, that it needs an oracle call for the Halting-problem to do so). The probability that A is replaced by B is then . There is no way to decouple the selection step from the mutation step in an algorithmic mutation, although this is not clear without the technical details which I will postpone until a future post. Chaitin’s model does not have random mutations, it has randomized directed mutations.

The high level description of algorithmic mutations given in Chapter 5 is not necessarily inconsistent with random mutations, but it is not detailed enough to make a concrete judgement. We have to look at Appendix 2 (*The Heart of the Proof*) to really understand how Chaitin’s mutations act. As before, an organism is a halting self-delimiting program, and ‘s fitness is the integer outputs upon halting. I will use to mean the running time of and will set for a non-halting program .

A mutation works as follows. calculates a lowerbound of Chaitin’s constant , where is the set of programs smaller than bits in length and halting by steps. calculates a new number and mutates into . Here is a self-delimiting prefix that finds the first such that , outputs , and halts. If then a halts and is thus an organism with fitness . If then is a non-halting program and thus not an organism (or at best an organism with an undefined fitness ). Chaitin’s mutations either return a strictly more fit organism, or do not return one at all (equivalently: an organism with undefined fitness).

To simulate evolution (as opposed to a deterministic picking of mutations), Chaitin selects the mutations randomly (with mutation being selected in proportion to ). This is probably why he writes them as ‘random’, however picking a directed mutation at random, is just randomized directed mutation. The concept of a mutant having lower fitness, is undefined in metabiology. A defense would be to say that algorithmic mutations actually combine the steps of mutation and selection into one — this is a technique that is often used in macroevolutionary models. However, I cannot grant this defense, because in macroevolutionary models, even when a fitter agent is always selected, the mutations are still capable of *defining* an unfit individual. Further, when macroevolutionary models set up such a hard gradient (of always selecting the fitter mutant) then these models are not used to study fitness because it is trivial to show unbounded fitness growth in such models.

Is Chaitin’s model the simplest it can be? Chaitin spends the first four chapters defending algorithms/software as metaphors for genes; Does metabiology actually use the power of algorithms? Chaitin does not attempt to address abiogenesis in his model and the first organism is an arbitrary program. Every subsequent program arises from the original by a sequence of algorithmic mutations; but every mutation returns an program of the form where is some rational number greater than 0 and less than . In other words, the genes are only capable of programming:

N = 1

whiledoN = N + 1end

I hid the subroutine that computes but we will see that it is a superficial feature. and the N that the algorithm returns are completely equivalent. A larger returns a larger N. Since the prefix is always repeated, I will just represent organisms by the rational number after . Instead of , I will write . Now, I can simple re-define the fitness function:

and the mutation operator:

and metabiology remains completely unchanged, with the exception of the original organism which we can just set as 0 for our purposes. Of course, instead of the fitness growing higher and higher it grows to be a better and better lower bound for . All the algorithms are stripped away, except in that comes from algorithmic information theory. However, we don’t need to achieve all of Chaitin’s results: we can use any irrational number between 0 and 1 like (in fact, the number doesn’t even need to be irrational it just has to have a non-terminating expansion in base 2). In other words, the algorithmic part of metabiology is superficial.

Further, by looking at metabiology in the simple terms I described above we can also overcome the directed nature of ‘algorithmic’ mutations. We just modify the mutation operator to be indexed by K and either – or + with both K and – or + selected from some distribution. A natural distribution is to pick K proportional to and – or + uniformly. Now, we can define a random mutation operator:

and

Then given a focal organism and a mutant we can use our favorite selection rule to chose who survives. A tempting one is to use Chaitin’s hard-max and let whoever is larger survive. Alternatively, we can use a softer rule like takes over with probability proportional to (this is a popular rule in evolutionary game theory models). Alternatively, we can stick ourselves plainly inside neutral evolution and just say always takes over regardless of fitness. This would create a random walk model, which can still show an increase in complexity as proposed by Gould (1997) and summarized on this blog by Julian.

### References

Chaitin, G. (2009). Evolution of Mutating Software EATCS Bulletin, 97, 157-164