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.
I have no current plans to get drawn into a discussion of how biologically realistic the Dawkins Weasel program is or is not. Most here seem agreed that it’s not intended to be biologically realistic, and I don’t much see the point.
The claim that my program fails to demonstrate the power of cumulative selection because it’s not biologically realistic is, in my opinion, a real stretch.
Why does a computer algorithm need to be biologically realistic in order to demonstrate the power of cumulative selection?
Just how biologically realistic does a program have to be in order to be able to demonstrate the power of cumulative election?
Without an answer to those questions I see no reason to pursue that particular line of objection.
Yes, you caught me. 🙂
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?
If my code uses a partitioned search, what kind of search does the Weasel program use?
Oh, and I also looked for any mention of a cumulative selection algorithm and again came up empty. Just not my day I guess.
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.
For example, the Dawkins search space partitions out the vast majority of the ASCII character set, using only the uppercase letters and a space. My program just does Dawkins one better. And my program is more flexible than his when it comes to what can be used for the target phrase.
Besides, what does the size of the search space have to do with whether or not I am using cumulative selection?
Is there a minimum size requirement? A maximum size limit?
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?
Mung,
Seems to be, by their reckoning, that writing something to demonstrate cumulative selection is as easy as pie, literally. If you make a pie, you are choosing only the things that go into making a pie, therefore you have cumulatively selected for that pie.
1. My program begins by choosing a random sequence of 28 characters.
def make_baby
Array.new(TARGET_LENGTH).map {CHAR_SET.sample}
end
2. My program ‘breeds from’ this random phrase. It duplicates it repeatedly, but with a certain chance of random error – ‘mutation’ – in the copying.
def mutate weasel, trait
weasel[trait] = CHAR_SET.sample
end
3. My program doesn’t compare the progeny to the target phrase and pick the one that “most resembles” the target. That’s not very realistic, imo. So another advantage my program has over the Dawkins Weasel. But my program still manages to converge on the target phrase by cumulative selection.
==================================================
So I think my program demonstrates the power of cumulative selection at least as well as the Dawkins program, if not better.
But no, I did not attempt to duplicate the Dawkins program. What would be the point of that? Surely there’s more than one way to demonstrate the power of cumulative selection.
For those who say that my program does not demonstrate the power of cumulative selection, what changes need to be made to my program?
phoodoo,
keiths took the Weasel program and added to it. Good for him.
I took the Weasel program and subtracted from it. My bad.
But “the pie” is still the same.
METHINKS IT IS LIKE A WEASEL PIE
Is it just me, or has this thread been pretty free from name calling and abuse?
It can be done.
I’ll not comment on the lack of walto’s presence in the thread and how that may or may not be relevant to the missing or reduced flaming.
😉
Mung, pick a number between 1 and 9
I understand the Weasel code, that’s not the issue here. The issue is how to demonstrate the power of cumulative selection. In software development terms, what are the requirements? Please see my reply to Elizabeth.
Yes, I really do want to understand the requirements necessary to demonstrate the power of cumulative selection.
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.
But I want to pick the number 9. Why can’t I pick the number 9? Oh, wait. I know the answer to that one! Because it’s not a number between 1 and 9. Does it have to be an integer? Can I use binary?
Do you mean, please pick an integer from the following set of integers {2,3,4,5,6,7,8}?
ok. i’ve picked one.
Mung,
You failed because you didn’t understand Weasel — or cumulative selection. You just wrote a program that had the word “Weasel” in it.
Not only did you fail, but your program merely demonstrates the rather uninteresting fact that if you randomly choose one character out of a set of twelve, over and over, you will eventually choose each character in the set.
Boring and irrelevant.
What did you pick?
Well crap. You disappoint me sir! I thought you were going to divine the number I picked. I was desirous of seeing a skeptical magic trick. I certainly gave you enough clues. =P
I picked the number 8. It is the number closest to the number 9 from within the set of integers between the numbers 1 and 9. I really wanted to pick the number 9. No offense to the number 8, it is a fine number, but it is not the number 9.
So?
Can you set out the requirements that a program would need to meet in order to demonstrate the power of cumulative selection?
Can you tell me what adjustments I need to make to my own program in order to have it demonstrate the power of cumulative selection?
If not, why are you here? If the best you can do is declare that I failed, without saying how or why I failed and how to repair the alleged defect, why should anyone listen to you?
keiths, you have some coding skill. I can see that. What do you think about testing? I am a fan of testing. Testing is a great device for demonstrating that the code meets the requirements.
Tell me what tests I can write to confirm whether or not my code demonstrates the power of cumulative selection. Please. I’m talking about what everyone here at TSZ loves. Empirical validation. Give it to us.
Mung,
He gave you complete, paramatized code…
Mung,
Lower!
Mung, how about you post a pseudocode version of your program.
So?
The Dawkins Weasel program chooses those exact same 12 characters, else it would never converge on the target phrase. Your own version of the Weasel program does the same thing for the same reason.
In essence your objection is the same as that which was already raised and dealt with, which is that I changed the size of the search space.
So what.
You’re smart. I’m dumb. You said people here would help me. Please do.
If you’re still confused after making an effort to study it, then bring your questions here and I’m sure people will help you out.
I am willing to test my code against your requirements. What is the first test I should write?
Like KF before, rejection comes before understanding
petrushka:
Here’s my description of what Mung’s program does.
If that’s accurate, it’s bizarre.
Mung:
keiths:
Mung:
So, if your goal is to show that the power of cumulative selection is illusory…
…your chances would be better if you actually understood Weasel and cumulative selection.
petrushka,
It is accurate, and it is bizarre. 🙂
Mung,
Here’s what I said:
I don’t see any evidence that you’ve made an effort.
Break the process down into sub processes. 😉
One of the reasons I like Ruby is that in many cases it can read like pseudocode. So I don’t have much practice in actually writing pseudocode and probably suck at it. I’d much prefer to improve the readability of the code.
At the beginning of the program I define four “constants” (In Ruby, everything is dynamic, even constants, lol).
# self explanatory?
#
TARGET_PHRASE = “METHINKS IT IS LIKE A WEASEL”
# convert a string into an array of characters
# perhaps a change of name is in order
# TARGET_PHRASE_AS_ARRAY
#
TARGET = TARGET_PHRASE.chars
# sets the number of characters in the target phrase
# perhaps a change of name is in order
# NUMBER_OF_CHARACTERS_IN_TARGET
# the length of the array should equal the length of the string
# TARGET_LENGTH == TARGET_PHRASE.length
#
TARGET_LENGTH = TARGET.length
# create an array of the characters in the target phrase
# but consisting only of the unique characters
# (removes duplicate characters)
# perhaps a change of name is in order?
#
CHAR_SET = TARGET.uniq
Comments? Questions?
Mung,
It isn’t worth it. Your program is too far off the mark. Better to start with a version of Weasel.
Here’s my recommendation:
1. Learn what cumulative selection is.
2. Learn how Weasel works, how it implements cumulative selection, and what it achieves thereby.
3. Once you’ve accomplished #1 and #2, it should be obvious why Weasel succeeds and why its success depends on its use of cumulative selection.
4. You can confirm your newfound understanding by experimenting with my version of Weasel. First, confirm that it converges quickly on the target phrase. Then set ENABLE_SELECTION to 0, recompile, and rerun. You will see it fail to converge.
5. Look at my code and notice that ENABLE_SELECTION has a very specific effect. If selection is on, genotypes are sorted by fitness and the fittest ones are selected for reproduction. Otherwise, the reproducing genotypes are chosen randomly:
if (ENABLE_SELECTION) { // selection enabled
// sort the genomes into descending order by fitness
qsort(genome_array, POPULATION_SIZE, sizeof(genome_t), compare_fitness);
} else {
// randomly scramble the genome array
scramble_genomes();
}
6. If the light fails to dawn by that point, then come here and ask some questions.
I am totally on board with that! Where can I go to find out what cumulative selection is? You do know, don’t you, that all along in this thread I have been asking that question.
If one is going to demonstrate the power of cumulative selection, one ought to know first what cumulative selection is, and second how to demonstrate it’s power
I’ve proposed that those who claim to know what cumulative selection is, and who claim to know how to demonstrate it’s power, set forth a means to test whether or not my program demonstrates the power of cumulative selection.
Have you ever written tests before keiths? I can show you how.
Let me put it another way. How do you know your own code demonstrates the power of cumulative selection? Did you write tests and observe that your code passed the tests? Care to share those tests?
I’m going to go way out on a limb here and guess that no, you did no such thing. You don’t know whether or not your program demonstrates the power of cumulative selection because you never wrote tests to validate that your code demonstrates the power of cumulative selection.
Hell, I’d bet that Dawkins himself had no automated test cases that his code passed.
You probably don’t even know what such a test would consist of.
I want to learn what cumulative selection is. The best way for me to learn what cumulative selection is, is for someone to write a test case, or test cases. Then we can not only see if I understand what cumulative selection is, we can also see if you do.
If you can’t write a test for it, you don’t know what it is.
How can I know that it implements cumulative selection? I should take your word for it? By faith we understand the power of cumulative selection.
An objective test, keiths. That should settle the dispute. If not, why not?
I’ve not been arguing that Weasel fails or that it’s success does not depends on its use of cumulative selection. THINK keiths. FOCUS keiths.
My program succeeds and it’s success depends on its use of cumulative selection. If you say otherwise, devise the test that can resolve the dispute.
It’s code, keiths. It can be tested.
This is starting to get old.
I have no way of knowing whether or not your program implements cumulative selection. I have no objective way of testing your claim.
If the test for cumulative selection consists of whether or not the algorithm converges on the target sequence, then by that definition my program implements cumulative selection. If not, why not?
Devise a test that can distinguish the result of my program from the result of your program and which can resolve the dispute over which one does or does not implement cumulative selection.
If you can.
Mung – can you describe in an English sentence how your program determines how close it is to the target (fitness)?
If the target is
“Me thinks it is a weasel”
what do
“xxxxxxxxxxxxxxxxxxxxxxxx”
“Mxxxxxxxxxxxxxxxxxxxxxxx”
“xMxxxxxxxxxxxxxxxxxxxxxx”
score?
My code doesn’t bother with ENABLE_SELECTION. For your code it’s a nice touch, but for mine it’s superfluous. In my code ENABLE_SELECTION is always on. I’m trying to demonstrate the power of cumulative selection, not the non power of non selection.
Is the ability to turn selection on and off a requirement for demonstrating the power of cumulative selection? Do you think Dawkins’ program had that feature?
Can you propose a test for whether or not the state of ENABLE_SELECTION has enough of an effect to warrant a conclusion of the power of cumulative selection?
Only one question. Can you devise an objective test that can be implemented in code?
I’m willing to subject my code to such a test.
Mung,
That’s right, because you don’t understand cumulative selection. If you did, you could look at my code and confirm that it employs cumulative selection when ENABLE_SELECTION is set to 1.
Your lazy ignorance is the problem here.
Yes, where in this world could you possibly go to learn about cumulative selection?
So? At this point I have only his word that it meets the requirements. I want to see the tests. I want to see his code passing the tests.
Well that is your shortcoming, not his. Does it compile? Does it execute? Does it find the target? Is it obfuscated?
You’re not looking very good Mung, and I suspect KeithS will play this to make you look even worse.
It’s bizarre. 🙂
Mung:
Riiiiight.
Let’s review.
First you claimed that that my goal was to show that Weasel cheats.
Then you claimed that my goal was to show that Weasel is illegitimate.
Now you claim that my goal is to show that the power of cumulative selection is illusory.
Let’s review some additional facts:
I’ve agreed that Weasel demonstrates the power of cumulative selection.
I’ve stated that my own program demonstrates the power of cumulative selection.
Software can be tested in order to demonstrate that it meets the requirements. This applies to the code that keiths writes, and it applies to the code that I write.
Tests, keiths. Get cracking!
Sure. Write the tests.
I’ve asked (nicely) asked a question about proximity to target. Would you like to start there or will you should up shop and asks for “tests” very post?
Sure. It doesn’t.
My program, unlike the Dawkins and keiths programs, does not compare each candidate solution to the final target. It’s a better Weasel than Weasel.
I could go to people who claim to know what cumulative selection is.
I could ask them to write a test.
Oh wait. Been there. Done that.
And I answered your question.
Rich:
Mung:
MungWee meant to do that.
-1
keiths,
I predict semi-quasi-latching hilarity!