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.
Lower!
Meanwhile, we await the tests.
keiths, kindly post the code that you used to validate that your program implemented the requirements.
-2
Mung,
So we’re clear, you mean 8-2=6?
Good for you!
#define ENABLE_LATCH 0 // if set, enabling latching
erm, that’s from the code of keiths.
Does that mean that his code does not demonstrate the power of cumulative selection?
Mung,
Did you read the ‘weasel wars’ threads at UD, Mung?
8=8
-2=-2
6=6
A=A
This is the wrong thread for discussing atheist nonsense.
keiths can support his claims or he must recant.
Maybe I did. Maybe I didn’t.
links, please.
Better yet, relevance.
Oh okay, you’ve wandered out of the 1 to 9 range (apologies for lack of clarity) both -1 and -2 get a “higher!”
If my program fails to implement cumulative selection then there ought to be an objective test which can demonstrate that my program fails to implement cumulative selection.
I await that test.
Here’s a few:
http://www.uncommondescent.com/?s=weasel
I’m actually doing you a favour, by trying to protect you from the mistakes of dipshits of yesteryear. 😉
Mung,
Of course you do. You’re too lazy to do it yourself, just as you’re too lazy to learn how Weasel works or what cumulative selection is.
Mung, you’ve completely failed to substantiate your claim that “The ‘power of cumulative selection’ is an artifact of the design of the program.”
Why not simply accept defeat, then go back and declare victory at UD as you usually do?
If at some point in the future you actually believe that you’ve found a way to support your claim, bring it to us and we’ll examine it. Until then, you’re just wasting our time with your silly demands.
If you want to be spoon-fed, then pay someone to do it. And no, I’m not interested in the job.
Says Mung, who wrote his program without even understanding the requirements:
Then later:
He still doesn’t know.
10 goto 10.
20 print “Weasel found”
Good luck finding that, evolution!
Editz for homphone
Aw Mung. It’s okay you don’t understand cumulative selection. That no-one is willing to help you but we’re all willing to laugh is a function of how you’ve conducted yourself this far. Take a leaf out of Sal’s book, turn it around.
Mung,
Like I said, you wrote your program without understanding the requirements. You were too lazy to study Weasel and too lazy to learn about cumulative selection, so you just jumped in and wrote a crap program that looks bizarre to people who actually understand the concepts.
It was a standard Mung fail, of the kind we’ve come to expect from you.
Rich, to Mung:
Indeed.
Thank you. I’ve presented for your inspection a program that I wrote. It does or it does not demonstrate the power of cumulative selection. What is your opinion?
I love this thread. I ask for empirical demonstration and the critics ask me to have faith.
… and gave you complete code.
Not in dispute. So what is your point. If you have one.
I am willing to subject my code to empirical testing.
If the critics here at The Skeptical Zone are incapable of producing empirical tests I am willing to say so.
you might want to research before you criticize seems a good one for you and ID in general 😉
Are you saying that you do understand the requirements?
Shall we say that you wrote your program with a full understanding of the requirements?
Then surely you can present for all to see, your tests. Or not.
Mung,
Then test it. Nobody’s stopping you. Quit whining about how we aren’t doing your work for you.
Come back when you can actually support your claim about Weasel:
I might want to do research. ok. I’m not opposed to doing research.
Sorry, but you are babbling. Nonsense.
keiths bows out.
Great!
> Replace the part where you mutate a letter by replacing it with a randomly chosen one until the correct result is obtained, with a subroutine or block of code that simply examines all 27 possibilities in alphabetical order until it finds the right one.
> If the new program doesn’t converge at all or converges too slowly to be useful, then your (unmodified) program can be said to pass the test.
> Otherwise, it fails.
Why should I do that? Why should I examine all the possibilities? The whole point of cumulative selection is that all possibilities do not have to be examined.
My program passes the test.
Come back when your claims can be tested.
Can you post the durations for the original and modified versions?
In a way it does, but I still think I answered it. But let me try again with specific reference to the terms in your rephrased question:
I would say:
Does that do it? A gives you Descent with [random] Modification; B gives you Natural Selection; C tells you whether the first two did in fact lead to Cumulative optimisation. (not sure what “cumulative selection” means, but I’m hoping I understood you correctly).
phoodoo,
Indeed. So why is Natural Selection such a difficult concept to grasp? It’s trivially true. Clearly, evolution does not have ‘wants’. Other than that, your summary is NS in a nutshell. Keep the things that survive better in a particular environment and discard the things that don’t. Keep doing it. Viola! – cumulative selection. (Yes, that’s right, viola. It started out as a mistake, but I like it).
I think one of the problems people have with Darwin’s idea is that it’s too simple to grasp. People even call it a tautology! It isn’t, but it’s a near-syllogism. It almost can’t not work.
What do you call it when it doesn’t work? Viola da gamba? 😉
Mung,
It needs to be a sufficiently close analogue of the arena in which cumulative biological selection takes place to serve that purpose – the purpose of being a demonstration of cumulative selection at work.
It needs some consistent means of evaluating variant strings in a comparative manner, to establish survival/discard criteria in an analogue of ‘natural’ selection. It needs to have mutation set at a level somewhere greater than zero, but less than a level at which all progeny are, effectively, completely random. It needs … well, that’s it, actually.
Since Mung complains that we demand too much resemblance to the natural phenomenon, I tried to devise a test as general as possible:
– it must use some (pseudo-)random quantities to explore the “search” space and
– the use of randomness must make it considerably more efficient than a brute force “search” over the same space.
Of course, we know the only way that can happen is cumulative selection.
If you want to make it sound more IDey, you can even calculate the “Active Cumulative Selection”, defined as -log2 ((runtime of cumulative algorithm program)/(runtime of brute force algorithm)) 🙂
No, that’s what you call it when it DOES work!
Mung,
I suspect that your requirement meetings on pretty much any topic except this one go a lot smoother. There seems to be some resistance to getting it. “What do you mean by ‘print’? OK, so if I wrote the result on a banana, would that satisfy the requirement? Can I test that the program does what it needs to do by just printing out the intended result and not bothering with the rest?”
‘Selection’ means that there is some comparative metric between strings in a digital population, and part of the population fails to breed on the basis of it.
‘Cumulative’ requires that the output from one round goes into another (though whether cumulative selection can actually be achieved depends on the evaluation step).
‘Mutation’ means that any part of any string can be changed – including, if you take a Weasel-y line, allowing matched positions to become unmatched.
The main things that would make a program built on those lines fail to demonstrate the power of cumulative selection would be the settings of your evaluation metric (which affects the ruggedness of the landscape) and your mutation rate (zero and very high do not work). A test of whether a particular set of parameter values demonstrated the power of cumulative selection would be if it got a result consistently faster than a parallel program doing random picks.
Obviously, other programs (ad absurdum, simply printing out the target) would clearly outperform this. And there are parameter settings (zero/high mutation/’rugged’ fitness function) that would fail. But a program cannot demonstrate the power of cumulative selection if it does not even possess the basic operations which lead to it.
One could write a more subtle version, minus some of the distractions of target and environmental ‘choice’ One could get the program to pick its own parameters for a given run. eg, a random integer I which represents the binary checksum of an ASCII string, and another random parameter M which represents the chance of a given bit-position being mutated (flipped, in this instance). You could keep them ‘secret’, known only to the program. By going for checksum you are ignoring the content of the string – the ‘target’. There may actually be many potential targets on this basis (although drift would eventually winnow the results to one winner).
Then you generate your random starting population, and plot the distribution of checksums. You iterate evaluation (using closesness to I as your criterion) and operate mutation based on M, stopping occasionally to replot the distribution of checksums. A parallel program just keeps generating ‘starting populations’ without the evaluation/mutation steps, and plots on the same axis.
Some runs will fail to do anything different from random. Peeking at the parameters, one might detect a pattern as to which values cause these ‘fails’. Other runs, you will be able to guess (from the peak of the distribution as it converges) the value of I. There are likely to be numerous possible solutions, before drift sorts the remainder.
Some of these runs will demonstrate the power of cumulative selection. Others will demonstrate some of the things that oppose it.
I already recommended the thread “Uncommon Descent Contest Question 10: Provide the Code for Dawkins’ WEASEL Program”. For background, you can read “Conservation of Information in Search:Measuring the Cost of Success” , by Dembski and Marks [IEEE TRANSACTIONS ON SYSTEMS, MAN, AND CYBERNETICS—PART A: SYSTEMS AND HUMANS, VOL. 39, NO. 5, PP1051-1061.]
You should be able to spot the error in this paper.
In Dembski and Marks’s terms: “Proximity Reward Search”
No. Partitioning reconfigures the search space, dividing it into smaller independent searches (one for each letter).
I am fairly confident that your code fails Vanellus vindex’s empirical test. Please provide the data to support your claim that:
as Vanellus requested here
Weasel was a didactic tool, through which Dawkins compared the power of cumulative selection to monkeys banging on typewriters. Implicitly, the “monkeys” version entails one evaluation step – “does the monkey-produced string = the target string?” Eons pass.
Weasel allows even slight improvements in a string to feed back into the process cumulatively. Mutations that confer even a single increment of resemblance of progeny string to the target string are favored for further reproduction, and those with more such increments are selected over those with fewer. Unlike the monkeys version, in which only attainment of the target counts, even very slight improvements make a difference in Weasel – one of the didactic points Dawkins wished to illustrate. Demonstration of the importance of slight changes to selection therefore therefore entails comparison of entire progeny strings with one another, the possibility that one string may be rated as “closer” to the target than another, and feedback of favored strings back into the process.
Mung’s program is absent this whole-string evaluation and comparison, as he admits. So it omits the very selection step that Dawkins seeks to illustrate. Absent selection of that sort, and absent feedback of incremental success back into the process, it is absent the “cumulative” component as well.
Keep in mind that the purpose of Weasel was to illustrate a couple of relatively narrow didactic points about selection. It was never intended to be a model of biological evolution.
keiths,
I read Mung’s code and keiths’ summary is accurate. Mung has created the perfect latching weasel, and just in time to give it to Kairosfocus for Saturnalia.
Mung:
…of doing Mung’s work for him.
Wake me up if at some point you think you’ve stumbled upon a way to defend your claim:
So am I! I await the data eagerly…
Mung,
Here’s my latest version of Weasel.
Use “gcc -std=gnu99 weasel.c -o weasel” to compile it.
While it is running, you can
1) type ‘s’ to toggle selection on and off; the current state is indicated in the display;
2) type ‘p’ to pause the program, and then any key to continue;
3) type ‘t’ and the program will prompt you for a new target phrase;
4) type ‘q’ to quit.
You will see that:
a) with selection on, it converges on the target phrase;
b) with selection off, it drifts away;
c) when the target is changed, it converges on the new target as long as you have selection turned on.
keiths,
But does it pass Mung’s test!!???