Calling ID’s Bluff, Calling ID’s Bluff…

In July, I described a Genetic Algorithm that, unlike Dawkins’ “Weasel” experiment, specifies no fixed “Target” for the simulation, but instead rewards those members of the current population which use fewer or shorter segments to connect a fixed set of points. As the algorithm progresses, it finds a multitude of answers for the math problem called “Minimization of Steiner Trees,” i.e. the shortest possible straight-line networks connecting the fixed points.

Last Monday, I posted Take the Design Challenge, wherein I called for solutions to a tricky little 6-point network. Next Monday, I will announce the winners (there are 20 entries already, several with true Steiner Solutions, and others with almost-as-good “MacGyver” solutions).

Imagine my surprise, then, when I found Salvador Cordova at Uncommon Descent spewing blatant falsehoods about this work. I was shocked - shocked, I say - to catch the UD Software Engineers in a lie. And quite a lie it is - with the help of mathematicians like Carl Gauss, I’m going to lift the veil from the obfuscations of IDers, and prove it’s a Lie, much as you would prove a mathematical theorem.

In his reply to the Design Challenge, Mr. Cordova describes a genetic algorithm of his own devising, for solving the problem of adding up all the integers from 1 to, say, 1000. (The result is 500,500, by the way). Cordova writes

The following computational theatrics are akin to what Dave Thomas performed:

ofro wrote:
What I don’t understand is the basic premise of your example, which apparently already has an explicit solution of the problem built into the program.

I’m afraid that isn’t quite correct because if you go to ga.c, and do a text search for 500500 you won’t find it. The solution was never explicitly stored anywhere.

It seems Sal is implying that his sum-of-integers genetic algorithm has no “fixed target,” and is akin to my work on Steiner Trees.

That is patently False. Cordova’s algorithm is exactly like Dawkins’ “Weasel”, with the major difference being that, while Dawkins was searching for the specific target “METHINKS IT IS LIKE A WEASEL,” Cordova is searching for the specific sequence of numbers 251, 252, 253, … 750. When these are summed and doubled, the result is the sum of the numbers from 1 to 1000: 500,500.

Another oddity was that Cordova’s code wouldn’t even compile – it took me a couple of hours to reverse engineer it and figure out what in tarnation he was doing. As an exercise in Smoke and Mirrors, Cordova’s algorithm is remarkable. But, unlike my program, it is definitely looking for one, and only one, Answer.

PROOF

Cordova’s program loops from 1 through half the desired end-number; if the sum of the first N integers is desired, and N=1000 (as in Cordova’s listing), then he loops from 1, 2, 3, up to 500 (=N/2).

For each of the 500 numbers, Cordova stores a number that represents a “Midpoint Distance” (I’ll call this MidPoint[i] for short, where i is any number in the sequence 1, 2, 3, … N/2.)

Initially, his Midpoint Distances are generated randomly, with values anywhere from -2N to +2N (e.g. -2000 to +2000). Then, he loops through each of the N/2 numbers once per generation, and repeats the process over many generations. For a given generation, and a given looping number from that generation (such as i=37, with value MidPoint[37]), Cordova calculates a “pseudo-euclidean distance”:

Here’s how he uses this distance. At each step in the loop (from 1 to N/2), the “distance” to the current MidPoint value is examined, and a “mutated” MidPoint distance is also derived, always within a few units (plus or minus 2.5) of the original “distance”. If the Mutated “distance” is shorter, that distance then replaces the current value, MidPoint[i]. Otherwise, the current value is retained. So, something is definitely being minimized, but what?

Aside: if you think this exposition is getting too wordy, please do try to figure out Cordova’s Code for yourself. I’ll wager you’ll be back here before you know it!

If the pseudo-Euclidean distance is called D, then Cordova is trying to minimize D = (x1-y)^2 + (x2-y)^2. To see where this will lead, one can take the derivative of D with respect to y, and set it to zero to find the extremum (which is indeed a minimum, but I’ll leave that detail to the reader):

Whatever x1 and x2 are, Cordova’s function will be minimized when the value of y (which turns out to be a MidPoint value) equals the average of x1 and x2.

Delving deeper into Sal’s Nightmare, one finds that, if you are on the ith number in the loop (say, i = 37), what gets sent down as x1 and x2 are just the index i itself, and that same index + N/2. Thus, for i=37, it turns out that x1 = 37, and x2 = 537. Not coincidentally, the average of 37 and 537 is 287, or simply 37 + 250.

And that’s almost all there is to it. Even if the value for the 37th midpoint was far off at the beginning (say, -1634), as the generations proceed, any mutations that serve to bring the midpoint closer to the intended value (=287) are accepted, and those that don’t are rejected.

Formally substituting i for x1, and i+N/2 for x2, we see that midpoints are drawn inexorably to the value
y = (x1 + x2)/2 = (i + i + N/2)/2 = (2i + N/2)/2 = i + N/4.

If N is 1000, N/4 is 250. The first midpoint (for loop index i=1) is drawn to 251 (=1 + 250), while the 37th midpoint is drawn to 287 (=37 + 250), and the final index’s midpoint is drawn to 750 (=500 + 250).

All that remains is to evaluate the final “estimate,” which is just the sum of the 500 (or N/2) midpoints, doubled.

Here follows the proof that this sum is just a roundabout way of calculating the sum of the first N integers, which the brilliant Gauss found useful as a child to escape some boring math drills: instead of adding the numbers up, Gauss realized the sum of the first N numbers was just (N*(N+1)/2).

And that’s that. Unlike the normal he-said/she-said arguments, this disagreement boils down to basic Math.

The Software Engineering Team of Uncommon Descent has been caught lying - Q.E.D.

Okay. I’ve seen better looking code in the Obfuscated C competition, but enough with the ad hominems.
Cordova’s claim of “I’m afraid that isn’t quite correct because if you go to ga.c, and do a text search for 500500 you won’t find it. The solution was never explicitly stored anywhere.” is technically true. Or at least, everything in that after the word “because” is true. It’s equivalent to running a genetic algorithm, where the fitness is determined by how close the ROT13 of the phrase is to “ZRGUVAXF VG VF YVXR N JRNFRY”. You won’t find “METHINKS IT IS LIKE A WEASEL” in that, but it is comparing it to a specific goal. The fact that goal is calculated - without any randomness added - from constant inputs for a given value means that the goal is hardcoded into the algorithm. You can try to slice it up, or hide it, but it will still be there.

In his reply to the Design Challenge, Mr. Cordova describes a genetic algorithm of his own devising, for solving the problem of adding up all the integers from 1 to, say, 1000. (The result is 500,500, by the way).

I derived & proved a formula for such when I was a 16 year old math nerd.

Imagine my surprise, then, when I found Salvador Cordova at Uncommon Descent spewing blatant falsehoods about this work. I was shocked

No you weren’t, no more than I! I know you say this tongue in cheek, but you’re going to be quote-mined as being in the camp of those who believe that Sal isn’t a lying-for-Jesus scum-of-the-earth charlatan and, well, might even have a chance at gaining entry to … “heaven”, I think they call it.

That is patently False. Cordova’s algorithm is exactly like Dawkins’ “Weasel”, with the major difference being that, while Dawkins was searching for the specific target “METHINKS IT IS LIKE A WEASEL,” Cordova is searching for the specific sequence of numbers 250, 251, 252, … 750. When these are summed and doubled, the result is the sum of the numbers from 1 to 1000: 500,500.

Slight correction, the start of the sequence is 251, not 250.

To generalize what Sal has done, he is searching for the specific string of numbers that meets the following algorithm: (N/4)+1, (N/4)+2, (N/4)+3, … (3N/4), where N is the number in question. For odd numbers, the string will be non-integers (all will end with #.5), even numbers will have integer strings.

Yeah, I’m not a big fan of lying interpretation. It’s much easier to point out that the work was (at the very least) incompetent, and it’s useful to point out that Sal doesn’t really understand GAs, but that doesn’t stop him from criticizing them.

By in large, I think Sal didn’t even get much support over at UD (despite saying that the engineers could “see through the charade”). His arguments just weren’t very convincing or thought out - though, I think that’s largely due to the fact that he’s arguing against reality.

Here’s the problems I’ve seen with the arguments over at UD and why all of them fall flat:

Actually, no. What GAs show is that it is possible to create systems via evolutionary mechanisms where the removal of any component makes the entire system fail. Really, there are two classes of IC then: “Class A” systems which can be constructed incrementally, but (at some later stage) fail if one piece is removed, and “Class B” systems which cannot be constructed incrementally and fail entirely if one piece is removed. Simply pointing out that a biological system fails if one piece is removed doesn’t tell you whether you’re dealing with a class A system (which evolution can create) or a class B system (which evolution cannot create). Careful research is needed to differeniate between then two, and IDists want to jump to the conclusion that any IC system is actually a class B system. GAs illuminated the fact that not all IC systems are class B systems (as IDists would like to argue).

By in large, Sal’s general argument seems to be that GAs, whether or not there is an explicit target, employ a very specific and limited strategy to find a specific solution. What Sal misses is the fact that GAs are much more capable he gives them credit for. First of all, Sal’s “GA” (if you can call it that) is specifically setup to hone-in on a solution to a problem that has one and only one solution. Actual GAs, on the other hand, are well known to be able to find completely different solutions (on different runs) to a single problem - they aren’t secretly preprogrammed with the solution, hard-coded to hone-in on that solution, or merely deriving the solution through a series of deterministic mathematical steps. GAs are moving through complex space and finding varieties of solutions that satisfy it’s goal.

The selection process is intelligently designed. However, that isn’t particularly relevant when you understand how GAs work. The selection process (or fitness function) is used to determine which organisms (real or digital) go on to reproduce. The descendent organisms are similar to the parents that they descend from. Thus, a selection process gets evolution moving in a particular direction. Since we want a particular outcome (e.g. shortest route between six points), we want each subsequent generation to be closer to that goal and so we allow the best ones to have children. It’s not the goal that gets the organisms to evolve in a particular direction, but it’s actually the survival differential that makes them evolve. The GA goal is simply used to determine who reproduces and who doesn’t - in other words, it determines how the survival differential is applied across the population. In the absence of a goal, the organisms can evolve in a particular direction simply by having a survival differential - provided that the differential is non-random. In the real world, organisms are hunters, prey (by predators and micro-organisms), and competing for mates. This produces a somewhat stable (and non-random) survival differential that allows real-world organisms to evolve. Hence, it’s really not necessary to have an goal for evolution to work. (Another way to look at it is to say that nature does have a goal, and that goal is to produce organisms that reproduce - of which survival is an important part.)

“Thank you for responding. Can you, for the benefit of the reader explain what would happen to this algorithm in the absence of
1. intelligent design of the selection process
2. intelligent design of the “creatures” such that they are amenable to intelligently designed selection”

GAs generally aren’t used to create ecologies of organisms that need to eat, hunt, evade predators, or compete for mates. In the absence of a goal or any of those needs, GAs won’t create anything at all because there’s nothing to create a survival differential (no goal, no competition, no starvation) - everybody survives, everybody reproduces (on average) at similar levels, and that means nobody evolves. You don’t need a goal to have GAs evolve, but you do need a survival differential (or more accurately a reproductive differential) in order to have evolution.

“Rather, this circuitous route serves the anti-design case by sneaking away the fine-tuning into the things you just listed: CPU, OS, GA engine, etc.”

The CPU and OS aren’t “sneaking” anything into the simulation. They are analogous to having a universe that works by laws. Being allowed to alter them is a little bit like saying that you should be allowed to alter fundamental forces of the universe and still have biological evolution work while you (for example) alter the binding properties of carbon, make hydrogen an unstable element, turn nitrogen into a noble gas, or increase or decrease the electromagnetic or gravitational forces by several magnitudes. While it would theoretically be possible to sneak things in via the GA engine, the engine is right there for everyone to see and scrutinize. It still works when nobody is pulling any sneaky business. The purpose of GAs isn’t to answer the question of whether the universe is designed or not, but it illuminates the question of whether GAs can, in the presence of stable fundamental laws, create CSI. Under those conditions, the answer is “yes”. Further, you can verify in the code that we are maintaining a relatively hands-off approach to the system and allowing a few simple rules (random mutation, selection, reproduction) to create our complexity. If there is a breach of this (for example, if we alter the organisms’ genome by inserting pre-designed information), you are entitled to complain, but there isn’t one.

(BTW, I’m posting this at UD, but I think I’ve been banned for disagreeing with Denyse’s post claiming that evolution is a cult. If it doesn’t appear there, you’ll know why.)

That’s nice work, but I think one of your conclusions is overdrawn. There is a difference between “it seems Cordova is implying” something untrue, and “Cordova is lying.”

It sounds to me like Cordova is saying only that the answer itself (500,500) is not part of the code, but his primary point is the argument that one can specify an answer without explicitly spelling out the answer. Indeed, his whole point is that simulations like this are merely exercises in using an algorithm to obscure the fact that the outcome is programmed in. You have elucidated that this is the case in Cordova’s algorithm, but that does not, in itself, diminish his point.

Not that I agree with Cordova’s criticisms of genetic algorithms either, of course. I just think perhaps you rushed to a conclusion regarding “lying.” Let’s just say his criticism is irrelevant, since your example finds a truly unknown solution, as opposed to coding for a specific predetermined answer to the problem.

Mind if I just run through a few definitions to get this all clear in my head?

There are two major divisions of genetic algorithm fitness function: extrinsic and intrinsic. Extrinsic ones are ones which are imposed by means of an explicit fitness function (this algorithm would be an example). Intrinsic ones are ones where the organisms follow behavioural rules and these rules themselves give rise to a sort of fitness value for the organism (examples include the Tierra simulation and the Real World [tm]).

What we’re discussing here is a further subdivision between extrinsic fitness functions that are locally or globally described. The former is more biologically realistic in that it simulates “blind” evolution better. The latter is less realistic, and is usually only used for demo purposes. The difference is that, if you know the global fitness function, using a GA is completely redundant.

It is of course possible for all three types of fitness to describe the same landscape. For example in the case of the Steiner solution, the same fitness landscape could be described by the following approaches:

1) Extrinsic/global - a complete listing of the lengths of the network for all conceivable patterns of nodes and lines

2) Extrinsic/local - a fitness function which selects possibilities on the basis of their length

3) Intrinsic - consider a population of line/node patterns, plus a population of “predator” organisms. These could be short lines which appear at random and “eat” anything they fall on. This would create a strong selective pressure towards shorter lines.

All three approaches describe the same landscape, and examples like this are the reason why it’s generally considered valid to use GAs with extrinsic/global fitness functions as examples.

Can anyone with more knowledge than me confirm whether that’s broadly accurate?

Have to say I agree with a couple of other posters. It’s one thing to say that someone’s critique of your original post was inadequate, incompetent, incorrect, etc. It’s another to say that your critic is a liar. That requires a whole different level of proof which, quite frankly, is not evident in your post. I think maybe you should go back and tone down some of the indignation as, other than that, it was a very revealing read as to why ID criticisms of GAs are bankrupt.

What sort of person writes what is supposed to be a non-deterministic algorithm, but only provides one fixed and immutable pathway down which it may travel? Salvador Cordova is such a person, apparently. I was surprised to find that Cordova’s code returned exactly the same answer on multiple runs, so I had a look inside. His idea of pseudo-random number seeding was this:

It’s another to say that your critic is a liar. That requires a whole different level of proof which, quite frankly, is not evident in your post.

You are wrong. Dave’s post does have that level of proof.

Return your attention to what Dave quoted that Cordova was responding to:

ofro Wrote:

What I don’t understand is the basic premise of your example, which apparently already has an explicit solution of the problem built into the program.

An “explicit solution” is not just the literal numeric constant “500500” as Cordova misleadingly responds. Dave does show that, yes, Cordova’s program does indeed include an explicit solution to the problem. Cordova’s response to “ofro” is an explicit falsehood. If you want to grant that it was a falsehood caused by stupidity rather than intention, that remains the only other alternative available that I see. Myself, I think the congruence between apparent intent and result makes “lie” by far the smarter pick.

My challenge to Salvador and the UD Software Engineering Team is simple and straightforward: if the Target’s “shirt” (a stated desire for the shortest connected straight-line networks) is indeed as “CLOSE” to the “Target” itself (the actual Steiner Solution for the given array of fixed points) as you say it is, then you and your Team should be easily able to deduce the proper answer, and send it along.

I’ll be waiting! See you next Monday, August 21st. - Dave

Thomas mis-describes the sense of my argument. The specification of a problem solving STRATEGY and successfully implementing that STRATEGY will yield solutions equivalent to some or all of the solutions in the solution space (or maybe good enough). Thomas mis-describes my position again. Aiming for the shirt versus the person is like aiming to find the right strategy. That’s what I meant. If he mis-understood for whatever reason be it me or him, I hope this helps clarify the issue.

With respect to my ga.c, of course I knew the program was rigged. I knew the seach strategy would work. Searching for a strategy is like finding a sufficient aimpoint. I provided 4 inexplicit strategies:

brute.c
gauss.c
recurs.c
ga.c

Each is a different strategy for hitting the same target. 4 different sets of driving directions leading to Rome from 4 different starting points, so to speak.

Of course the programs fitness function was rigged, and it’s no less rigged than the Steiner-solving GA’s. That’s the whole point. Did Dave Thomas not know in advance his fitness function would have a chance of being marginally successful (in a MacGeyver sense at least), or did he have some monkey code his fitness functions or describe the fitness function to him?

By the way, I’m honored to see Dave is effectively calling me liar.

cheerio guys,
Sal
PS
computing Fermat points is a bit tedious, if I have inclination I might provide them and finish of my speculation for a solution to his problem

Re Don Baccus’s query about my being “shocked,” do go out and see “Casablanca” with Humphrey Bogart and Ingrid Bergman - it’s a cultural reference thing.

Re Kevin Vicklund’s note about the series starting with 251, not 250 - it’s been corrected. Thanks.

Re several comments to the effect that using the “Lie” word was not justified - I’m with Wes on this. Cordova has repeatedly described my claims that the Steiner genetic algorithm does not have its answers hard-wired in as a “sham,” “Orwellian Double speak,” and so on. (Details are here.)

The specific Lie this post discusses is found here, where Cordova wrote the following about his genetic algorithm for summing N numbers, ga.c:

This program will give the answer to question, “What is the sum of the numbers from 1 to 1000?” through a genetic algorithm. … The following computational theatrics are akin to what Dave Thomas performed:

Cordova’s genetic algorithm to sum the first N integers is a sham and a hoax, as I’ve shown. It gives the appearance of getting to a solution without a specified Target, but there is indeed just such a Target. The “Lie” is that Cordova is claiming that my Steiner genetic algorithm is doing the exact same thing, just not “overtly.” That is simply false, as we all will see next Monday, when the winners of the Design Challenge contest are announced.

Sometime soon I’ll post on a few coding tricks which Uncommonly Dense Software Engineers can use to determine if their genetic algorithms have a fixed Target, or not.

Wes, my version of the Cordova Code, using srand(0) for the seed, gets the answer 500,500 by generation 4108. Maybe our compilers have different random generators?

Sal’s comment appeared while I was composing, so I didn’t see it before my last comment.

I do thank him for repeating his prevarication again, in bold no less:

Of course the programs fitness function was rigged, and it’s no less rigged than the Steiner-solving GA’s. That’s the whole point.

My program is “rigged” only in the sense that it has been developed to solve math problems without known or given answers. Cordova complains that if I suddenly starting switching lines in my code, it wouldn’t work. But what does that prove? All my program does is show that, given a suitable environment (such as “shorter/connected networks are preferred”), evolutionary processes can indeed find effective solutions.

Go ahead with your Fermat point, Sal. When you get that figured out, you’ll finally get to Third Place (as you’ll see on Monday next).

Guys, could you please tone it down with your polemic! I realize that you are’nt exactly the best of buddies. I knew I didn’t get the most truthful of answers from Cordova, and I was going to consult with my son to analyze the code and prepare a reply. You saved me that trouble. At the same time, if I had known that my comment/answer was going to be exploited that much, .…

You are taking the fun out of telling the folks over at UD about experimental facts that the hard-core don’t want to hear, but maybe some visitors will listen and think if arguments are handled in a more civized manner. I have to admit UD’s civility is a design feature that I appreciate even if the content makes me cringe at times.

(And I won’t admit that in my younger years I probably would have adopted a more raucus style, too)

Cordova’s genetic algorithm to sum the first N integers is a sham and a hoax, as I’ve shown. It gives the appearance of getting to a solution without a specified Target, but there is indeed just such a Target. The “Lie” is that Cordova is claiming that my Steiner genetic algorithm is doing the exact same thing, just not “overtly.” That is simply false, as we all will see next Monday

Just because he made a false statement doesn’t necessarily mean that he knows it to be false and is attempting to deliberately trick people into believing a known falsehood. The key point to make is that Cordova’s claim is false – to accuse him of deliberately lying is to risk diverting the reader’s attention from this point to a less-provable (and less important) point about whether or not this is deliberate.

Maybe he is wrong because he knows the truth and hates it so much he wants to trick other people into believing a lie. But I doubt it. I think it’s more likely that he has rationalized this to himself, and finds his argument to be the best way to avoid acknowledging natural mechanisms capable of mimicking ID. That would be self-deception, not lying. A slight but significant difference.

I think your point is much stronger if you focus on the incorrectness of the claim, rather than on the inferred motives of the claimant. Science does not currently provide us with a means of objectively detecting an intent behind the behavior given only the evidence of the behavior itself. You may subjectively suspect a deliberate intent to deceive, but you cannot actually prove it, for the same reason you can’t make ID scientific.

All of this is good, of course. But we would do well not to forget the big picture, which is that evolution (by known/knowable mechanisms) is an explanation, the only meaningful one, for what we see in the organic world. Genetic algorithms are attempts to mimic what has been reasonably inferred from the evidence, and have been generally adapted to serve our own purposes rather than to reproduce the meaningless yet amazing complexity that we observe in the world of organisms.

That is to say, the template for all genetic algorithms, the explanatory theory of evolution by known (perhaps by some yet unknown as well) mechanisms is what is really at issue. RM + NS (+ the rest) is what fits the data found in biology, the neutral rates of evolution, the lack of rational design in organisms, the derivative nature of all of biology. No known designer, or any other phenomenon, has ever produced anything like it.

Genetic algorithms using essentially RM + NS typically reproduce the patterns that we see in undirected evolution–divergences, derivation, non-rational design. This is what they are good at showing, whether or not they are directed toward some goal. The lack of goals in biological evolution only makes the search space much wider, something that Sal would prefer to smother over with meaningless challenges to replicate evolution computationally. That is to say, IDists like to put evolution into question using non-empirically-based challenges, rather than to deal with the actual evidence that gave us the idea of genetic algorithms in the first place.

We have a superb example of undirected evolution in the biological realm. No goal or rational design has ever been demonstrated there, while the endless evidence of derivation is the almost the entire theme of biology. So I applaud Dave Thomas’s excellent work at coming up with an undirected evolutionary analogy to use in computers, however I don’t want the squabble with those who avoid empirical modeling like the plague to obscure the fact that Sal et al haven’t in the slightest dealt with the success of undirected RM + NS + in explaining what we see in ourselves and in our world.

We have an explanation (one that is well beyond exact duplication–don’t think that isn’t the reason why they demand such a duplication), they have none. It’s no wonder that Sal turns away from the actual biological evidence in order to deny the fact that we have a very good explanation, yet it is only a measure of how unscientific his thinking is. He is not trying to come up with an explanation in order to help us understand the details of what we see, he is only trying to prevent the use and propagation of the successful explanation that has been partly adapted for our own use–because it comes up with solutions that humans would not readily think of.

Why do we want to use genetic algorithms at all, Sal? Surely if the organic realm were chock full of rationally-designed mechanisms we would have little reason to try to mimic an evolution that simply provides the same sort of rational designs that humans and computers produce. No, we looked at organisms, saw that they are not rationally-designed, yet often enough had useful alternatives to rational designs that we thought we would do well to supplement intelligent design with a measure of evolution, and so we came up with mimics in order to supplement intelligent design. We use genetic algorithms to mimic the non-intelligent designs produced by evolution, so that we can supplement our intelligent rational design with solutions similar to what we observe in the organic world. All genetic algorithms create patterns analogous with the patterns found in life reproduces important aspects of RM + NS +, and non-teleological genetic algorithms only come closer to making a true mimic.

Why use evolutionary processes at all if they only produce what is indistinguishable from intelligent designs anyhow?. Can Sal differentiate between evolutionary processes and rational intelligent design processes, as well as to identify the differences in their results?

All of this is good, of course. But we would do well not to forget the big picture, which is that evolution (by known/knowable mechanisms) is an explanation, the only meaningful one, for what we see in the organic world. Genetic algorithms are attempts to mimic what has been reasonably inferred from the evidence, and have been generally adapted to serve our own purposes rather than to reproduce the meaningless yet amazing complexity that we observe in the world of organisms.

That is to say, the template for all genetic algorithms, the explanatory theory of evolution by known (perhaps by some yet unknown as well) mechanisms is what is really at issue. RM + NS (+ the rest) is what fits the data found in biology, the neutral rates of evolution, the lack of rational design in organisms, the derivative nature of all of biology. No known designer, or any other phenomenon, has ever produced anything like it.

Genetic algorithms using essentially RM + NS typically reproduce the patterns that we see in undirected evolution–divergences, derivation, non-rational design. This is what they are good at showing, whether or not they are directed toward some goal. The lack of goals in biological evolution only makes the search space much wider, something that Sal would prefer to smother over with meaningless challenges to replicate evolution computationally. That is to say, IDists like to put evolution into question using non-empirically-based challenges, rather than to deal with the actual evidence that gave us the idea of genetic algorithms in the first place.

We have a superb example of undirected evolution in the biological realm. No goal or rational design has ever been demonstrated there, while the endless evidence of derivation is the almost the entire theme of biology. So I applaud Dave Thomas’s excellent work at coming up with an undirected evolutionary analogy to use in computers, however I don’t want the squabble with those who avoid empirical modeling like the plague to obscure the fact that Sal et al haven’t in the slightest dealt with the success of undirected RM + NS + in explaining what we see in ourselves and in our world.

We have an explanation (one that is well beyond exact duplication–don’t think that isn’t the reason why they demand such a duplication), they have none. It’s no wonder that Sal turns away from the actual biological evidence in order to deny the fact that we have a very good explanation, yet it is only a measure of how unscientific his thinking is. He is not trying to come up with an explanation in order to help us understand the details of what we see, he is only trying to prevent the use and propagation of the successful explanation that has been partly adapted for our own use–because it comes up with solutions that humans would not readily think of.

Why do we want to use genetic algorithms at all, Sal? Surely if the organic realm were chock full of rationally-designed mechanisms we would have little reason to try to mimic an evolution that simply provides the same sort of rational designs that humans and computers produce. No, we looked at organisms, saw that they are not rationally-designed, yet often enough had useful alternatives to rational designs that we thought we would do well to supplement intelligent design with a measure of evolution, and so we came up with mimics in order to supplement intelligent design. We use genetic algorithms to mimic the non-intelligent designs produced by evolution, so that we can supplement our intelligent rational design with solutions similar to what we observe in the organic world. All genetic algorithms create patterns analogous with the patterns found in life reproduces important aspects of RM + NS +, and non-teleological genetic algorithms only come closer to making a true mimic.

Why use evolutionary processes at all if they only produce what is indistinguishable from intelligent designs anyhow?. Can Sal differentiate between evolutionary processes and rational intelligent design processes, as well as to identify the differences in their results?

Maybe it would help if Salvador quits his computer for a while, orders a peptide (e.g. Methinksitislikeaweasel) and a phage display library (NEB # E8121L, 1480,-$) and tries some phage panning. Media and plastic ware are inexpensive and the experiments can easily carried out by people not too experienced with wet experiments. Even if DI had to buy the necessary equipment (which seems quite likely if one looks at the number of experimental papers they have published) less then 5000$ should be sufficient to set up the lab for this purpose. If one of you guys would invite him in his lab less then 2000,-$ will be sufficient for the complete experiment. Indeed he would have enough material for WD´s research assistant to run the experiments in parallel.
He would experience everything important in evolution: randomness (phage library), selection (panning) and reproduction (amplification of selected phages in bacterial host cells).
However, I am afraid that he would deny this, because the suggested library contains all possible heptapeptides, which he would interpret as front loaded.

Good points, people. Tell you what - if Sal wishes to stop misrepresenting my work by saying things like this in today’s new UD post:

I fully take pride in the smoke and mirrors I used, I never pretended otherwise. In contrast, Thomas refuses to admit he’s also using smoke and mirrors in his GA.

then I will take back my charges of lying, and apologize.

But that won’t happen until Cordova actually admits that I’m not feeding specific solutions into my algorithm. In Cordova’s genetic algorithm (GA), there is one unique answer hard-wired in. In mine, there is not. That’s the main bone of contention.

As long as Sal continues to insist that my Steiner genetic algorithm is rigged in the same way that his Gaussian sum genetic algorithm was rigged, as he says in comment #120215 above, I’ve got a problem.

I’ve just finished dissecting Sam’s “masterpiece”, and, Ouch ! methinks , the “incompetent and unaware of it” article was written exactly about him. This is not even a genetic algorithm the guy produced at all ! What a shame…

As has been said before, even on this thread, there is some heuristic utility to demonstrating to the doubtful, untutored, or fence-sitters that ID is a sham (and most of its best-known practitioners shameless shamsters).

The same cast of poseurs has every vested interest–psychological, religious, and at times professional and financial–to engage in obfuscation, misdirection, fact-fudging, logic-twisting, and outright prevarication, as they attempt to slither off the well-set hook. However “polite” and “politic” it might be to pretend to ignore this deeply-engrained habit of falsehood, it would neither be fair, ethical, or truthful to do so.

In Sal’s case, however, we also seem to be dealing with some rare species of psuedo-intellectual masochist.

The demands of ethics are thus rendered more complex: clearly we must continue to expose the vacuousness and illegitimacy of his “arguments.”

Whether it is “better” to continue enabling Sal’s self-flagellation by assiduously exposing his moral vacuousness–or whether one should refrain from further fueling his perverse pleasures–is a delicate moral question indeed, perhaps best left to the discretion and scruples of each individual.

Until Cordova acknowledges that there is a difference between these two approaches, I’ll be reluctant to withdraw my conclusion that he’s not telling the truth.

Should he make this acknowledgment, I’ll be happy to change my tune.

You’re quite free to say that he’s not telling the truth, as far as I’m concerned. If what he says happens to be untrue, then it’s perfectly fair to say he’s not telling the truth. And I agree that it’s only fair to judge him by the same standards as you are judged: if you shouldn’t accuse him of lying, then he shouldn’t accuse you of deliberately refusing to admit the truth, for the same reasons.

My only point is that people think psychologically more often than logically. If your side of the argument is that Cordova is deliberately and intentionally spreading lies, people who are ID-friendly or ID-neutral will be tempted to think that your side has lost if you cannot prove Cordova’s statements are intentionally deceptive. Since that’s nearly impossible to prove, you can be 100% about Cordova’s inaccuracy, and yet people may still conclude that Cordova won the argument. It’s much more effective to focus on the facts, and draw people’s attention to the discrepancy between what Cordova claimed, and what we actually find in the evidence.

I think multi-objective genetic algorithms are a better example, where there are multiple fitness functions and so a single optimal solution is never found. Instead you get a population of solutions that are a compromise of the different functions.

Sal Cordova’s response to Dave Thomas’ program is continuously to say, “It can’t prove evolution because the law of nature (i.e. natural selection) that the program relies on was programmed in by a human being. This is evidence of intelligent design.” That is, of course, laughable.

Sal and the IDers must respond this way, no matter what. To give even an inch on this point demolishes their entire premise.

Sal could be said to be either a liar, a fool or an ignorant. Which one is “less” insulting? It makes no difference since a person who in his field of studies cannot or is not willing to see the errors of his line of thinking even after been provided with the evidence does not deserve any respect at all.

I agree with you in the way Dave’s GA is a more close descriptor of evolution. The point in which Sal shows deception or willfull ignorance (take your pick) is in arguing that you have A SOLUTION as a target. Since the IDiots like Sal will program their models to arrive to that one solution hence arguing against evolution. ToE on the other hand will arrive at solutions that may or may not be the optimum but are good enough.

My favorite Sal Cordova lie was when he claimed that some professors (plural) had made some favorable comments about some ID peddling video or something, then when asked to give the names he suddenly switched to the singular and pretended that he had merely added an “s” accidentally.

Prior to that, I suspected that Sal was morally bankrupt before that because of his habit of bragging about converting kids with his false incomprehensible baloney. But when it became clear that Sal would lie about *anything* if he suspected he could get it away with, then the picture of Sal’s pathology really crystallized.

There’s something pathetic about watching people discuss science with Sal. It’s like watching a documentary film about a mentally ill person who is slowly killing himself.

I’m hoping that Salvador can address the fact that Dave’s program generates CSI. Dembski’s definition of CSI entails a pattern that’s tractably recognizable by a human, so even if a solution or near-solution is “embedded” in the program, it doesn’t constitute CSI unless we can look at the program and see the solution there. Dave’s program does not exhibit CSI, but the output of the program does. How do explain that, Salvador?

There’s something pathetic about watching people discuss science with Sal. It’s like watching a documentary film about a mentally ill person who is slowly killing himself.

That’s what it looks like to you or me, surely. But here’s the frightening bit: What do you suppose that it looks like from the perspective of someone who lacks sufficient specific familiarity with the underlying science/math/CS/whatever discipline to immediately grasp which side is the one that knows what it is talking about?

That’s what it looks like to you or me, surely. But here’s the frightening bit: What do you suppose that it looks like from the perspective of someone who lacks sufficient specific familiarity with the underlying science/math/CS/whatever discipline to immediately grasp which side is the one that knows what it is talking about?

“Um, that doesn’t address the point I was talking about, which was Cordova telling “ofro” that his code did not include an explicit solution, when we — and Cordova, self-admittedly — know that it does.”

I can’t see that he says so. He admits that he has used a “formula” (Gauss formula), but he doesn’t claim that this is an explicit solution. Instead he says: “I pointed out what explit meant in my usage, that means explictly using the string “500500â€³ in the program. The route toward that outcome was indirect, and inexplicit, or shall I say implicit.” ( http://www.uncommondescent.com/inde[…]rchives/1464 , comment 5.)

So I see room for a possible dissonance. He may think he implemented a GA as he may believe they work since he didn’t frontload the solution but a sufficiently deterministic algorithm. IanC suggests “simulated annealing” which seems to me a reasonable description. (Very little annealing.)

But I’m not sure how meaningful it is to discuss this if people know from other threads that Cordova is in fact lying.

I wonder how long it will take until this is taken as proof that mutations cannot produce IC.

From a survival standpoint, mutations might not want to produce IC. In the real world, organisms are “reduced” all the time from all kinds of mishaps, and often they go on living (and reproducing) just fine anyhow because living things have enough spare capacity to adapt.

Somehow, for example, I’ve known a several three-legged cats over the years that all got along just fine - oddly, IIRC, they were all named “tripod”.

In a truly optimized animal, where every part was perfectly designed so as not to waste material and energy, such a mishap might be catastrophic (well, more catastrophic). How many three-wheeled cars could go on in any meaningful sense?

The highest possible poker hand, a royal straight, never appeared. If “the solution” was hard coded into the selection routine, this should have been it, but it never appeared in all the times I ran the simulation. This makes sense, of course. Building pairs allows step by step improvement, but in poker a four-card straight isn’t particularly better than a three-card straight. You either have a full five-card straight or you don’t.

This is the most significant comment here, as it completely puts the lie to Sal’s BS. This point about the unevolvability of straights is the true version of creationist canard “what good is half an eye?” – an argument that Sal conveniently ignores in this case. Simply stating the optimization criterion – shortest network, highest hand, or accurate image formation – isn’t sufficient to reach it, there has to be an evolutionary path, as there is for Steiner networks and eyes but not for poker hands. If the optimal Steiner network is implicit in Dave Thomas’s GA, then the eye is implicit in biological evolution. If Dave Thomas’s GA is a case of “smoke and mirrors”, then so is biological evolution. But in any case, biological evolution is capable of producing the biological systems we observe, and the IDist arguments against it are thoroughly refuted.