Those Weasely IDCists!

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.

here

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).

here

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.

307 thoughts on “Those Weasely IDCists!

  1. keiths: MungWee meant to do that.

    Meanwhile, we await the tests.

    keiths, kindly post the code that you used to validate that your program implemented the requirements.

  2. Richardthughes: I predict semi-quasi-latching hilarity!

    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?

  3. Richardthughes: So we’re clear, you mean 8-2=6?

    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.

  4. 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.

    Oh okay, you’ve wandered out of the 1 to 9 range (apologies for lack of clarity) both -1 and -2 get a “higher!”

  5. 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.

  6. Mung,

    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.

    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.

  7. At this point I have only his [keiths’s] word that it meets the requirements.

    Says Mung, who wrote his program without even understanding the requirements:

    A few people suggested that I should write my own Weasel program.

    So I did.

    Then later:

    What are the requirements my code must meet in order to demonstrate the power of cumulative selection?

    He still doesn’t know.

  8. 10 goto 10.
    20 print “Weasel found”

    Good luck finding that, evolution!

    Editz for homphone

  9. Mung: Think of it this way. You come to me and ask me to write a computer program to demonstrate the power of cumulative selection. I know how to write code but I don’t know what it means to demonstrate the power of cumulative selection. For that, I need you to explain things to me. It’s what would be termed requirements gathering.

    So I am talking about a higher level than the level of code. I am talking about the requirements. What are the requirements my code must meet in order to demonstrate the power of cumulative selection?

  10. 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.

  11. 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.

  12. Rich, to Mung:

    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.

    Indeed.

  13. Richardthughes: I’m actually doing you a favour, by trying to protect you from the mistakes of dipshits of yesteryear.

    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?

  14. Mung:
    I love this thread. I ask for empirical demonstration and the critics ask me to have faith.

    … and gave you complete code.

  15. 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.

  16. Mung: Not in dispute. So what is your point. If you have one.

    you might want to research before you criticize seems a good one for you and ID in general 😉

  17. keiths: Like I said, you wrote your program without understanding the requirements.

    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.

  18. Mung,

    I am willing to subject my code to empirical testing.

    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:

    The “power of cumulative selection” is an artifact of the design of the program.

  19. Richardthughes: you might want to research before you criticize seems a good one for you and ID in general

    I might want to do research. ok. I’m not opposed to doing research.

    you might want to research before you criticize seems a good one for you and ID in general

    Sorry, but you are babbling. Nonsense.

  20. Mung:
    I am willing to subject my code to empirical testing.

    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.

  21. Vanellus vindex: > 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.

    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.

  22. Vanellus vindex: > 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.

    My program passes the test.

  23. Mung: I have asked many questions that have not been answered.

    My point? I guess it would be that everyone thinks the Dawkins Weasel program demonstrates the power of cumulative selection but no one seems to know how it manages to do so.

    I think I’ve just had an insight though. As is so often the case here at TSZ people probably think I am asking one question when I think I am asking a different question.

    I am not asking how the program is coded, I am asking how/why it is that THAT CODE manages to demonstrate the power of cumulative selection.

    Think of it this way. You come to me and ask me to write a computer program to demonstrate the power of cumulative selection. I know how to write code but I don’t know what it means to demonstrate the power of cumulative selection. For that, I need you to explain things to me. It’s what would be termed requirements gathering.

    So I am talking about a higher level than the level of code. I am talking about the requirements. What are the requirements my code must meet in order to demonstrate the power of cumulative selection?

    Does that help?

    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:

    What are the requirements my code must meet in order to demonstrate the power of cumulative selection?

    I would say:

    1. It must provide a starting population of virtual organisms who reproduce with random variation.
    2. It must provide an environment in which some variants have a greater chance of reproducing successfully than others.
    3. It must demonstrate that these two provisions result in lineages of virtual organisms in which features that tended to increase the chances of reproduction in previous generations are retained in subsequent generations unless replaced by an even more pro-generative feature.

    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).

  24. phoodoo,

    It demonstrates nothing other then if you select the things you want, and get rid if the things you don’t want, you get what you want. What a ridiculous an obvious point.

    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).

  25. 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.

  26. Keep doing it. Viola! – cumulative selection. (Yes, that’s right, viola. It started out as a mistake, but I like it).

    What do you call it when it doesn’t work? Viola da gamba? 😉

  27. Mung,

    Why does a computer algorithm need to be biologically realistic in order to demonstrate the power of cumulative selection?

    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.

    Just how biologically realistic does a program have to be in order to be able to demonstrate the power of cumulative election?

    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.

  28. Elizabeth: 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:

    It must provide a starting population of virtual organisms who reproduce with random variation.
    It must provide an environment in which some variants have a greater chance of reproducing successfully than others.
    It must demonstrate that these two provisions result in lineages of virtual organisms in which features that tended to increase the chances of reproduction in previous generations are retained in subsequent generations unless replaced by an even more pro-generative feature.

    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).

    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)) 🙂

  29. Mung,

    For you developers here, imagine being asked by your boss to write a program, and when asking for the requirements you’re told to just copy some other piece of code. You say you want to understand the requirements. Your boss says just read the code if you want to understand the requirements.

    That is a seriously defective software development process.

    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.

  30. 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.

  31. Mung: I’m not familiar with the term “partitioned search.” I’ve consulted a number of books on EA’s, GA’s GP, algorithms, and searching and sorting. Partitioniing seems to be related to sorting, not searching. Googling partition search algorithm was not much help either.

    I guess what I am saying is that I took your claim seriously and did some due diligence and came up empty. So can you say more and perhaps recommend some material?

    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.

    If my code uses a partitioned search, what kind of search does the Weasel program use?

    In Dembski and Marks’s terms: “Proximity Reward Search”

    Oh, and I also looked for any mention of a cumulative selection algorithm and again came up empty. Just not my day I guess.

    Vanellus vindex: Also, as I’ve already explained to you, it hardly demonstrates the power of cumulative selection, since you’ve reduced the search space (by partitioning, as DNA_jock notes) to the point where brute force is not only a viable alternative, but more advantageous.

    So DNA_Jock was referring to how I configured my search space? I used a smaller search space than Dawkins did, that I admit. But so what? By that criteria the Dawkins Weasel program is a partitioned search too.

    No. Partitioning reconfigures the search space, dividing it into smaller independent searches (one for each letter).

  32. 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.

  33. keiths,

    If that’s accurate, it’s bizarre.

    It is accurate, and it is bizarre. 🙂

    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.

  34. Mung:

    keiths bows out.

    …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:

    The “power of cumulative selection” is an artifact of the design of the program.

  35. 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.

Leave a Reply

This site uses Akismet to reduce spam. Learn how your comment data is processed.