A couple recent comments here at TSZ by Patrick caught my eye.
First was the claim that arguments for the existence of God had been refuted.
I don’t agree that heaping a bunch of poor and refuted arguments together results in a strong argument.
Second was the claim that IDCists do not understand cumulative selection and Dawkins’ Weasel program.
The first time I think I was expecting more confusion on Ewert’s part about the power of cumulative selection (most IDCists still don’t understand Dawkin’s Weasel).
In this OP I’d like to concentrate on the second of these claims.
I’ve never doubted the power of cumulative selection. What I ask is, where does that power come from and how does the Dawkins Weasel program answer that question? I’m capable of coding a version of the Weasel program. But I’m also interested in the mathematics involved. I’d like to see if we can agree on what is involved in the coding and how that affects the mathematics involved. What is the power of cumulative selection?
METHINKS IT IS LIKE A WEASEL
A string with a length of 28 characters. Each position in the string can assume one of 27 different values. 27^28 would be the size of the sequence space. Call it the search space.
Many critics of ID claim that evolution is not a search. But “the power of cumulative selection” is dependent upon this view of evolution as a search. After all, the Weasel program is a search algorithm. My view is that the Weasel program incorporates and relies on information that is coded into the program to make the search tractable. The “power of cumulative selection” is an artifact of the design of the program. We lack justification to extend this “power” to biology.
So are there people here who can explain the mathematics and the probabilities and make the necessary connection to biological evolution? Is it a mistake to think that Dawkins’ Weasel program tells us anything about biological evolution.
Keeping things that work better than what they replace is not a search.
It’s a search by certain non-standard definitions of a search.
I think one problem with the search methaphor is that it tends to presuppose that the size of the search space is knowable. It might be finite, but it’s important to realise that it’s not knowable, and the proportion of solutions within it are not knowable – evne the proportion of solvable problems isn’t knowable.
You only ever know there was a solvable problem when a population solves it.
Every non-fatal change to the genome is a solution.
The distinctive thing about biology is that every solution is a close neighbor of a previous solution.
The distinctive thing about the search space is that every solution is a close neighbor of another solution.
This is not a peculiarity of some designed space or physics. It is also true of arrays of logic circuits. As discussed in “Arrival of the Fittest.”
Nope, try again
The size of the search space in Weasel is knowable. It’s finite and doesn’t change during the running of the program.
How does that fact enhance the perception of the power of cumulative selection?
Put another way, if the program never halted, if it never found a candidate solution that matched exactly the target phrase, what sense then would people have of the power of cumulative selection based on the Weasel program?
I’m thinking none. You would not be able to tell which was better, a random search or a search using cumulative selection.
Given that people here can’t even agree on whether the program employs a search algorithm, what do you have against IDCists not understanding Weasel?
But I agree, that was what it was intended to show, and not much beyond that.
The question is, how does it manage to do that? I say it does so by magic. Sorcery even. 🙂
Following the code posted by keiths:
// set up fitness target
target.locus[ 0] = ascii_to_weasel(‘M’);
target.locus[ 1] = ascii_to_weasel(‘E’);
He’s straightforward about it. kudos. Sets up a target that will be used to determine fitness. I see he added a few twists, not just a plain jane program. For example, you can change the genome length. But the length of the candidate sequences will still be the same length as the target sequence.
I would like to see the changeable parameters loadable from file or set by menu so that you don’t have to recompile the program every time you want to change the parameters, because the questions I am asking involve changing the odds of a successful match.
IOW, we need to find which factors of the program provide it with it’s marked ability to demonstrate the power of cumulative selection. For example, if we change the fitness target every so often. Or if we allowed mutations to the candidate sequences that are not from a fixed set of the same characters as the target phrase.
Mung,
Why bother? The compilation only takes a fraction of a second (less than a tenth of a second on my machine).
And it’s no more labor-intensive to do this…
1) edit parameters at top of source file;
2) run script;
3) repeat
…then it is to do this:
1) edit parameters in config file;
2) run program;
3) repeat
If you understand the algorithm, the source of its power is easy to see. Net moves toward the target phrase tend to be kept while net moves away from it tend to be rejected. If individual moves take you closer to the target phrase then a sequence of such moves will do so as well.
In other words, the program is good at demonstrating the power of cumulative selection precisely because it uses cumulative selection. Disable cumulative selection and you’ll wait a gazillion lifetimes before seeing the program reach the target phrase.
The current code doesn’t allow you to change the target mid-stream, but if it did, nothing special would happen. The genotypes would just start converging on the new target.
Remember, the starting genotypes are randomized, but the program nevertheless converges on the target phrase. Thus, the effect is the same as if the program had been converging toward one target and then the target was changed to “METHINKS IT IS LIKE A WEASEL”.
That already happens. The target phrase doesn’t contain all of the letters of the alphabet, but the character set does.
Mung,
Whether you call it a search is just semantics. The interesting question is not what you call it, but how it works.
My complaint about IDers is that they typically don’t understand how Weasel works. KF’s infamous “latching” meltdown, for example, was the result of pure ignorance.
Mung,
Those are distinct conditions. You can achieve the first by simply setting FITNESS_THRESHOLD to a value greater than the number of characters in the target string. In that case no genotype can achieve a fitness that reaches the threshold and so the program will never halt. It will still converge on the target phrase, however, and so the power of cumulative selection will be visible as you monitor the intermediate results.
To achieve the second condition — the program running forever because it never finds an exact match — you just need to play around with the parameters. For example, setting the mutation rate to zero will guarantee that you run forever (provided that you don’t get astronomically lucky and hit the target when the starting genotypes are being randomized).
That’s not very interesting, though. It’s obvious that selection will fizzle out if the variation it operates on is not replenished.
Nobody disagrees about the algorithm. The only issue is whether it is reasonable to call any evolutionary algorithm a “search”. It’s not my favoured term, but in the sense that it’s used by people like Dembski, sure it’s a “search”.
Just don’t go looking for a searcher, and don’t go thinking that the search is trying to find a pre-specified target. It isn’t. It’s “searching” for an optimal configuration. In Weasel there is only one. In most scenarios there are a very large and unknown number, and some are situated on local maxima i.e. are only locally optimal.
Right. It’s extremely simple. In addition, the fitness function, the genotype and the phenotype are identical.
So it’s a special case. But it’s still an “evolutionary search”. And IIRC it was only built to show that the argument that “randomly changing text can only degrade it” is false, if the random changes are also accompanied by selection.
It’s been argued over out of all proportion to its point.
As I said, it demonstrates an extremely simply and actually blindingly obvious point, but you still see, occasionally “anti evolutionists” say things like “typos can only make a text worse not better”. Weasel shows that if random mutations are combined with selection, “better” can result.
Just graph the fitness of each generation relative to the starting string.
Because “better”, in evolutionary terms, simply means “greater chance of reproducing successfully in the current environment. In Weasel, the environment favours weasel-like strings, and the longer the program runs, the more weasel-like the strings become, until they accumulate so much weaselliness that no more weaselliness can be achieved.
In more useful algorithms, the environment is set up to favour things that solve problems – mobility, for instance, or effective discrimination between patterns. Unlike Weasel, the fitness function (“how mobile?”) is is completely different from both geneotype (the code that results in the thing’s properties) and phenotype (the thing, with its properties).
But the principle is the same. Unfortunately Weasel has led people to think that the algorithm designer must know the optimum solution. In the case of Weasel this is true (because it is built directly into the fitness function). In the case of any practically useful algorithm it is not true (or why would anyone bother?)
AVIDA is a much better example, because in AVIDA, only the fitness function is known in advance, not the solutions to performing the operations that increase reproductive chances.
keiths,
Um, One little problem.
There is no target phrase in evolution.
phoodoo:
phoodoo,
Um, one little problem.
I’m not talking about evolution.
Mung,
You already know the fittest genome. You don’t have to search for it … it was actually just a bit of a joke. Insert Mungism about me being a bit of a joke …
Allan, you said there was no search. Are you now recanting, or was that just a joke?
Did you mean to write: Weasel isn’t “really” a search anyway.
Or perhaps: Weasel isn’t a “real search” anyway.
Mung,
[smirks] Evolution is not a search. Weasel is … a demonstration of the power of cumulative selection.
Or perhaps IDers keep bringing Weasel up because they can’t actually understand any of the real models?
Mung,
It’s the algorithm that’s important.
Instead of wasting time worrying about whether Weasel is a search, study the code I provided. When you understand the algorithm, you won’t need to worry about whether the s-word applies.
They never understood WEASEL, so how could they understand something like Avida?
Why is it important, to you or to anyone, to get people to say out loud that the Weasel is a search? Or that it isn’t a search?
I don’t see what follows from that. Anything important?
If Evolution is a search.
Then Searches have targets.
Targets are like codes, it takes intelligent design.
Therefore the existence of targets proves ID is true.
That’s what I think they think, anyway.
Joe Felsenstein,
I think there are two strands: words like ‘code’ and ‘search’ have active, intentional-agent connotations, and someone who goes against a particular convention (or misspeaks, like Matzke in the ‘amino acid space’ thread) can be belittled, for debating points.
OK, I reread the Original Post.
Maybe the argument is intended to go this way:
1. Weasel is intended to show the power of cumulative selection.
2. Weasel can be considered to be simulating a search, carried out by cumulative selection.
3. Evolutionary biologists say that natural selection is not a search.
4. Therefore Weasel does not demonstrate that the power of cumulative natural selection.
… or is the argument different from this?
Joe,
Mung seems to be arguing that Weasel somehow “cheats”:
He doesn’t understand the program, so he thinks its necessary to run experiments like the following to expose the real source of its success:
I’m urging him to study the algorithm. Once he understands it, the source of its power should be obvious: it’s cumulative selection. There are no tricks. The code is straightforward.
I explained it to him earlier:
Maybe I’ll modify my program so that selection can be disabled by changing a parameter. It already has a mode in which it prints out the top genotypes every n generations. If we enable that mode and disable selection, the failure to converge should be obvious — even to Mung.
In keeping with the goals of this site, I am looking for common ground. Something we can agree on and from which we can then proceed.
Why is it so difficult for people here to agree on simple facts?
That’s the same goal I had in my posts about the genetic code. Not even Elizabeth was willing to admit that the genetic code was a code without then turning around and running from what she had just said.
If Weasel is in fact a search, is that relevant to it’s ability to demonstrate the power of cumulative selection? I say it is. But if other people are not even willing to agree that it’s a search what is the basis for further exploration of the subject?
Will people go ballistic if I say that EA’s and GA’s are in fact searches? Am I the only one to notice that Lizzie has already started the Lizzie shuffle?
The OP is about the power of cumulative selection and how it is that the Weasel program demonstrates that power. That whether it is a search is relevant ought to be obvious.
If Weasel is a search and evolution is not a search, then whether Weasel is a search seems relevant.
Especially given that at least one poster here claims that Weasel employs natural selection.
GA’s can implement a search, but they can also do other things. Search simply isn’t a good metaphor for evolution.
Where do I say that Weasel cheats? Where do I argue that Weasel cheats?
Weasel does what it does. It’s a computer program. How it could possible “cheat” is beyond me.
Given that you think that I think that Weasel “cheats,” this statement of yours can perhaps be forgiven as being based upon a faulty assumption. You, being the good TSZ citizen that you are, will substantiate your claim or retract it.
You can’t be serious.
I understand the power of the algorithm. The question on the table is what is it about the algorithm that demonstrates the power of cumulative selection.
Claiming that “the source of its power should be obvious: it’s cumulative selection,” doesn’t tell us anything at all relevant to the question. It begs the question.
You’re catching on. It’s not the algorithm. It’s the parameters.
You tweak the parameters and anyone running the program will not be able to tell that it’s any better than random selection.
Good point. Why not?
Why not limit the character set used when generating the candidate sequences to the same letters used in the target sequence?
“METHINKS IT IS LIKE A WEASEL”
METHINKSLAW plus the space character.
Now that would really demonstrate the power of cumulative selection! What on earth was Dawkins thinking?
1. Weasel does demonstrate the power of cumulative selection. This is not in dispute. I think we all agree on this. I hope we do.
2. Weasel is a search algorithm. It’s not a simulation of a search algorithm. Some search algorithms perform better than other search algorithms. Some people here at least appear to dispute that Weasel is a search algorithm.
3. Natural selection is not a search. Neither is cumulative selection. Some people here at TSZ seem to think that Weasel demonstrates “the power of natural selection.”
4. If natural selection and cumulative selection are not the same thing just say so. No need to resort to terms like “cumulative natural selection.”
Another joke?
petrushka, please explain the science and metaphor of Weasel to me.
If you can’t, have the grace to bow out.
– Genetic Algorithms in Search, Optimization & Machine Learning
– Genetic Algorithms in Search, Optimization & Machine Learning
Say it isn’t so.
In other equally surprising news: water remains wet, sun still rises in the east.
Are you renouncing your anti-gay bigotry?
Too funny.
Mung:
keiths:
Mung:
Throw it against the wall. See if it sticks.
WEASEL was designed to demonstrate a very simple phenomenon and refute a common falsehood. The fact that folks at UD spent months asserting that WEASEL couldn’t work without latching demonstrates that Dawkins correctly perceived how mathematically illiterate most IDists are.
It’s a demonstration of an old saw that says there three stages in the acceptance of new ideas. Denial, declaration that the idea is true but irrelevant, and declaration that it was too obvious to be important.
WEASEL very elegantly demonstrates that populations that produce more offspring than reproduce can change over time. It could easily demonstrate drift, or it could track a changing selection function. It makes no sense to call it a search. It is not looking for anything. Search is a metaphor, just as hunting is a metaphor in thermostats and Governors.
petrushka:
And by the way, Mung, my program has a parameter you can change to enable latching. Set ENABLE_LATCH to 1 and give it a try.
Not only is latching unnecessary, it doesn’t even make that much of a difference.
Be sure to mention that to KF next time you’re at UD.
Mung,
Here’s a new version of the program.
Change ENABLE_SELECTION to 0 and watch what happens to the fitness over time.
+1
Genetic algorithms are generally simulating a population which has a fitness function that a user wants maximized. It is a kind of search algorithm.
Genetic simulations (as carried out by population geneticists and quantitative geneticists) have a population and a fitness function. However the objective is different — it is to see what happens, to understand what forces affect that changes in the population. For example, we might want to know how much genetic variability is maintained at an overdominant locus in the presence of mutation and genetic drift. The optimum genotype is trivially obvious — a population all of whom are heterozygotes. But that is not the question of interest.
They may look rather similar but the reasons for running them are different. Genetic simulations are usually not thought of as searches by the scientists who use them.
Beautifully put, and absolutely key.
Because whether or not “A is a B” is true depends on how you define B.(and A, for that matter).
Lots of words, including “search” and “code” have many different meanings, mostly related, but some being more metaphorical than other. Language works like this a lot – a word starts with a specific meaning, and is then extended to cover similar things. Take the word “silo” for instance. Originally it meant a “pit for storing grain”. Then it became a word for vertical cylindrical towers for storing grain. And other things. Then vertical cylindrical bunkers for storing missiles. Then an organisational style in which there is little communication between hierarchies.
“A missile bunker is a silo” is a fact if we define silo to mean a cylindrical storage bunker. It is not a fact if we define silo to mean a pit for storing grain.
So it is a fact that under certain reasonable definitions of code, that DNA is a code. Under others it isn’t.
Same with evolution and search. You are finding contradictions where there are none.
But not beyond the folks at UD. Perhaps you should ask them, just to get a full picture.
Just search google for:
site:uncommondescent.com weasel cheats
Have you told your anti-gay bigot friends at UD you think they are bigots?
Moved a couple of posts to Guano.
Mung,
You know that thing where someone just rolls up every few days, and responds with smart-alec one-liners instead of simply answering directly?
I’m doing that thing.
That is why we are not entitled to our own definitions and why an objective standard for language is necessary for communication.
peace
That when a change is made to the sequence, if that change has higher fitness, it is retained instead of discarded. That’s it.
The main difference is that the measure of fitness in the WEASEL program is “how close the sequence is to the specific target sequence”.
In somewhat more realistic population genetics models, the population is not represented by one genotype, but by N of them (or an infinite number of them, in deterministic models). They may be asexual or they may mate and even have recombination. And the fitnesses no longer simply tell you which individual survives, they are instead the products of the probability of survival and the expected number of offspring. And it gets more complicated if the model has overlapping generations, then you can have age-specific birth and death rates for each genotype.
In such models, the cloud of genotypes moves in the space of genotypes. One can also make spaces of mean fitness, plotted as a function of gene frequencies (a la Sewall Wright 1932). For models of quantitative characters that are determined by multiple loci, one can also make surfaces of mean fitness as a function of mean phenotype (again, Sewall Wright, in the 1930s). Populations move roughly uphill on these surfaces, but not always. Genetic drift causes them to wander in a sort of Brownian Motion, in addition to the uphill pull of natural selection. Let’s not even get into A.N. Kolmogorov’s diffusion-equation approximations of all this (R. A. Fisher and Sewall Wright pioneered similar methods — yes, this is the same Kolmogorov who almost 30 years later invented algorithmic information theory).
All that is in theoretical population genetics, in work from the 1930s to the 1980s. Dawkins’s teaching example is in effect a population genetic model with asexual clones, a population size of 1 haploid individual, and very strong selection, so that a new mutant always fixes if its fitness is higher. Weakening the selection some, one would get a model where the population does an uphill-biased random walk, very similar to the Metropolis Algorithm.
How well populations do in coming to the global maximum depends on population sizes, recombination and mutation rates, and of course the shape of the fitness surface. Smoother is better, but the averaging of fitnesses by the cloud of individuals smooths the fitness surface somewhat. For evolution to succeed in creating well-adapted phenotypes, one does not have to find the global optimum, so it is misleading to call evolution a search for that optimum.