Weasels, ReMine, and Haldane's Dilemma

Post of the Month: September 1999

(this is my THIRD try at sending this, the rest disappeared into the
ether, but might turn up after 3 weeks, as a previous post did)

There has been some discussion on the newsgroups talk.origins and
sci.bio.evolution over the last year or so regarding Walter ReMine's
claims that a version of Dawkins' "weasel" program, which demonstrates
the efficacy of selection, nevertheless demonstrates a serious
limitation on the rate of evolution, in agreement with Haldane's
Dilemma, a rate so low that Mr. ReMine claims this makes the current
accounts of human origins (and other higher vertebrates) implausible
(see
http://x38.deja.com/getdoc.xp?AN=294263986 and
http://x38.deja.com/getdoc.xp?AN=315954300).

As I have written before, I can't for the life of me see how any
Dawkins style "blind watchmaker" program will reproduce Haldane's
Dilemma, as Haldane's Dilemma requires multiple genes (typically >
20,000), with a proportion of those genes having multiple alleles (see
http://www.gate.net/~rwms/haldane1.html or Natural Selection, George
C Williams, 1992, Oxford University Press, chapter 10). How a Dawkins
style selection program, with only one "gene" and no population
structure, could show Haldane's Dilemma, is not clear. Clearly many
other people thought that, including Wesley Elsberry, who produced
the Perl program "weasel.pl" (see
http://www-personal.monash.edu.au/~ianm/whale.htm) to explicitly
explore this claim, and Robert Williams, whose site I referenced
above.

Fortunately, Will Pratt of the University of Nevada found a copy, and
as a result Robert Williams was able to get a copy of David Wise's
program MONKEY (see
http://www-personal.monash.edu.au/~ianm/whale.htm), which ReMine used.
As I also noted earlier, after running it several times, and looking
at the code, I couldn't find any hint of Haldane's Dilemma in the
program. What was I missing?

The answer is actually blindingly simple, and is an embarrassment to
Mr. ReMine. Here are relevant excerpts from Mr. ReMine's book.

<begin quotes>
p 235

"That method of mutation is not true to nature [used by Dawkins]. In
nature nothing counts mutations and assures exactly one in each
progeny. A more realistic type of mutation should be used in the
simulation so that each letter has a probability of mutation.
Suppose we use this correct method of mutation while leaving the
"average" rate unchanged (at 1 chance in 28).
This subtle correction to the simulation nearly doubles the time
needed to evolve the target phrase: to 86 generations."

p 236

"Then we reduce the reproduction rate to that of the higher
vertebrates, say n=6. In a sexual species this would require the
females to produce 12 offspring each. This is overly optimistic for
many species. The simulation then goes into error catastrophe and does
not reach the target phrase. We can eliminate the error catastrophe
by lowering the mutation rate."

"Then by exploration we can find the mutation rate that produces the
fastest evolution [footnote: in this case the optimum mutation rate
is one in 56]. With this optimal mutation rate, on average, the target
phrase is reached in 1663 generations - that is 62 generations per
substitution."

"Thus the simulation - with its numerous unrealistic assumptions that
favor evolution - is less than five times faster than Haldane's
estimate of 300 generations per substitution. Ironically, this
suggests that Haldane was too optimistic about the speed of
evolution."
<end quotes>

Can you see where ReMine has made his error? I actually wasted a
couple of hours comparing the effects of mutation rates on different
programs before I realized it, but it should have been blindingly
obvious (so I'm stupid, okay, but I was expecting something subtle).

Here's the key line:
"Then we reduce the reproduction rate to that of the higher
vertebrates, say to n=6."

Well, knock me down with a stick of mortadella and call me Jake. Mr.
ReMine doesn't know how these programs work! In the vast majority of
weasel simulations, including Wise's, the program takes a string,
makes x copies of it with single letter mutations in one or more
copies of the string, then chooses the best string and makes x copies
of that with mutations, then chooses the best string from those
copies, and makes x copies ad infinitum until the target string is
reached. In many of these programs, the value x is a user entered
variable called "number of offspring" or similar wording.

The important thing to note is that in Wise's program, Dawkins'
original, Wesley Elsberry's weasel.pl and my WEASEL4.BAS (see sig)
the "reproduction rate", i.e. number of offspring, IS ALSO THE
POPULATION SIZE! Of course you will see only slow substitution in
any of these programs when you only have 5 offspring, as there is only
a TOTAL POPULATION of 5 strings at any one time![1]

Of course, in the real world, most organisms have populations of more
than 5 individuals :-). Trying to compare the substitution rate in a
population of 5 indviduals with the substitution rate in a population
of between 10,000 to 100,000 individuals is a pretty big blunder to
make, even allowing for the other problems in trying to compare this
program with a real population. The information about "offspring"
number isn't hidden, it's clear in the description given by Dawkins
and in David Wise's documentation.

ReMine's argument totally collapses, without even having to point out
the other, obvious problems.

Cheers! Ian
[1] Think about it, if you did do it the way Mr. ReMine thinks strings
are reproduced, then in a few generations an exponentially growing
number of strings will exceed the string space of any program.
=========================================================================
(Appendix: Wise's subroutine that generates the "population" from
offspring number)

PROCEDURE spawn;
{ SPAWN copies the "parent" string (index 0) into each
"offspring" string and then performs the selected "mutation".
NOTE: in each case, the letter position to be changed is selected at
random AND the letter to be placed there is also selected at
random. }
VAR
i, j, k :INTEGER;
BEGIN
FOR i:=1 TO num_copies DO
BEGIN
s[i] := s[0]; { Copy the "parent" }
IF (option <> 3) OR (i > 1) { Do not change if first child and option }
THEN { is 3(one child remains unchanged) }
CASE method OF
1 : s[i,(Random(msg_size)+1)] := letter_pool[Random(pool_size)];
2 : FOR k:=1 TO num_changes DO
s[i,(Random(msg_size)+1)] := letter_pool[Random(pool_size)];
3 : FOR j:=1 TO msg_size DO
IF Random < mut_prob
THEN
s[i,j] := letter_pool[Random(pool_size)];
END; {CASE}
diffs[i] := diff(s[i]);
END; {FOR i:=1 TO num_copies DO}
i := min_diff; { find offspring closest to target }
s[0] := s[i]; { make the offspring the next parent }
diffs[0] := diffs[i]; { save its difference for display }
END;