Efficient Per Query Information Extraction from a Hamming Oracle

{{bronze}}{{title-italics}}{{crenav}}
'''''Efficient Per Query Information Extraction from a Hamming Oracle''''' is a magnificent paper illustrating the art of obfuscation disguised as "[[science]]."<ref>[http://marksmannet.com/RobertMarks/REPRINTS/2010-EfficientPerQueryInformationExtraction.pdf Efficient Per Query Information Extraction from a Hamming Oracle], Winston Ewert, George Monta&ntilde;ez, William A. Dembski, Robert J. Marks II (pdf)</ref>

On March 9, 2010, [[William Dembski]] announced in his blog [[Uncommon Descent]] a "New Peer Reviewed ID Paper - Deconstructing the [[Dawkins weasel|Dawkins WEASEL]]."<ref>http://www.uncommondescent.com/evolution/new-peer-reviewed-id-paper-deconstructing-the-dawkins-weasel/</ref> Amusingly, [[Richard Dawkins]] isn't mentioned in the paper at all, or in its references (though those are at least not the usual sloppy copy-and-paste job we have seen in their earlier papers). No, the only hint that this has to do something with Richard Dawkins or [[evolution]] is the use of the phrase:

<code>METHINKS*IT*IS*LIKE*A*WEASEL.</code>

William Dembski — and his coauthors Winston Ewert, George Montañez, and [[Robert Marks|Robert J. Marks II]] — seem to think that they are criticizing Darwinian evolution by using their secret catch phrase.

But the main sentiment when reading it is a sense of ''déjà vu'' - or even ''déjà fait''.

If you hate math and technical crap, just skip to [[Efficient_Per_Query_Information_Extraction_from_a_Hamming_Oracle#What_has_this_all_to_do_with_the_theory_of_evolution_or_intelligent_design|this section]].

==Press release==
The inimitable [[Casey Luskin]] gets it all wrong when he arrives late to the party on Apr 8, 2010 with a press release<ref>[http://www.evolutionnews.org/2010/04/william_dembski_robert_marks_a.html William Dembski, Robert Marks, and the Evolutionary Informatics Lab Take on Dawkins’ “WEASEL” Simulation in New Peer-Reviewed Paper], Casey Luskin, April 8, 2010, [http://www.evolutionnews.org/ Evolution: News and Views]</ref> for the [[Discovery Institute]]:
{{cquote|This paper covers all of the known claims of operation of the WEASEL algorithm and shows that in all cases, active information is used. Dawkins’ algorithm can best be understood as using a “Hamming Oracle” as follows: “When a sequence of letters is presented to a Hamming oracle, the oracle responds with the Hamming distance equal to the number of letter mismatches in the sequence.” The authors find that this form of a search is very efficient at finding its target — but that is only because it is preprogrammed with large amounts of active information needed to quickly find the target. }}
*Whatever algorithm ''is'' being examined in this paper is barred from changing in-place characters - which means it's not the weasel algorithm,
*the paper doesn't cover ''all of the known claims of operation of the WEASEL algorithm''. Even the authors don't claim so,
*the ''Hamming Oracle'' is the fitness function the authors use for various algorithms - including Dawkins's weasel. To equate it with this algorithm highlights the depths of Luskin's lack of knowledge,
*the authors find that Dawkins's algorithm is comparatively '''in'''efficient,
*the efficiency or lack thereof of the weasel algorithm doesn't change the fact that it demonstrably works, and
*typically for ham-fisted creationist attempts to analogize information theory into biology, the term most central to Luskin's argument, ''active information'', is not defined, making any claims about its nature or quantity quite irrelevant.

==Abstract==
''Computer search often uses an oracle to determine the value of a proposed problem solution. Information is extracted from the oracle using repeated queries. Crafting a search algorithm to most efficiently extract this information is the job of the programmer. In many instances this is done using the programmer’s experience and knowledge of the problem being solved. For the Hamming oracle, we have the ability to assess the performance of various search algorithms using the currency of query count. Of the search procedures considered, blind search performs the worst. We show that evolutionary algorithms, although better than blind search, are a relatively inefficient method of information extraction. An algorithm methodically establishing and tracking the frequency of occurrence of alphabet characters performs even better. We also show that a search for he search for an optimal tree search, as suggested by our previous work, becomes computationally intensive.''

Is there any surprise here? Evolutionary algorithms are somewhat inefficient. So why are they used?
*They are relatively simple to program
*They don't need much knowledge about the fitness function, so they work in many cases
*They are quite stable
But of course, the more you know about the search space, the better you can tailor your algorithm. But this wastes a lot of ''thinking'', i.e., a much scarcer resource in most applications than computer time.

==I. Introduction==
In their earlier works [[Conservation of Information in Search - Measuring the Cost of Success]] and [[The Search for a Search - Measuring the Information Cost of Higher Level Search]], the term [[oracle]] wasn't used even once. Now, you find it over twenty times in the introduction alone. Maybe, the numerous comments on threads at [[Uncommon Descent]] proposing this view have worked. Or, as DiEb put it in his [http://dieben.blogspot.com blog] on Aug 26, 2009:
{{cquote|...And that's rather a pity: W. Dembski is a guy who is interested in information, and the amount of information which is transferred from a[n] environment into the algorithm. He should be interested in the flow of this information: How is this information exchanged? The answer: Via the conversation with the oracle....<ref>[http://dieben.blogspot.com/2009/08/white-screen-denise-oleary.html DiEbLog Aut 26, 2009]</ref>}}

Another quote: ''Oracles can be used with relative degrees of efficiency. In the most simple of examples using a ''needle in a haystack'' oracle, blind sampling without replacement outperforms blind sampling with replacement in terms of average query count.'' This seems to be obvious, but it is a new insight for William Dembski - in his draft to ''The Search for a Search - Measuring the Information Cost of Higher Level Search'' he thought of both searches as equivalent. So this paper - currently in peer review - should have undergone some serious changes.

==II. Information Measures==
The authors present their definition of ''endogenous information '' <math>I_{\Omega}</math> and ''active information per query'' <math>I_{\oplus}</math>.

==III. Markov Models for Evolutionary Search==
'''Continuing Error:''' From {{wpl|mutation rate|wikipedia}}: ''In genetics, the mutation rate is the chance of a mutation occurring in an organism or gene in each generation (or, in the case of multicellular organisms, cell division).'' So, what Dembski et al. call in the following ''mutation rate'' isn't the effective mutation rate: they allow for a letter not being changed with probability <math>\frac{1}{N}</math>. Thus, the ''effective mutation rate for example C (''Mutating Children With a Fixed Mutation Rate'') as seen by an observer is <math>\frac{N-1}{N} \mu</math>.
=== A. Markov Processes With an Absorbing State ===
Absolutely nothing new here. Everyone who does some analysis of [[Dawkins weasel]]- as [http://boundedtheoretics.blogspot.com/2009/10/never-look-gift-weasel-in-mouth.html Tom English] or [http://dieben.blogspot.com DiEb] - came up with this. That is basic stuff. They shouldn't have stopped here, but calculate - for instance - the variances, too. It's not much harder...

===B. Information Measures in Markov Searches===
Again, <math>I_{\oplus}</math> is defined, in this time for a special case.

===C. Markov Search===
Now, several examples are given.
*(A) '' '''K children with a single mutation''' ''
One of the most annoying habits of W. Dembski and his friends is to use anything but the standard notation. Numerous times they were made aware of the theory of ''evolutionary strategies'', which dates back into the neolithicum of computer science, the 1960s. And even the first reference<ref>'''Thomas Back''', ''Evolutionary Algorithms in Theory and Practice: Evolution Strategies, Evolutionary Programming, Genetic Algorithms''</ref> of their paper - a title the authors list with surprisingly few errors<ref>'''Thomas Back''' should be '''Thomas Bäck''' or '''Thomas Baeck''', per [[German]] orthographic conventions.</ref> - introduces this standard. So, their algorithm is just a variant of a <math>\mathbf{ES}(1,k)</math> evolutionary strategy - one parent, k children. The authors give us the transition matrix for this case.
*(B) '' '''Ratchet Strategy''' '' 
To everybody else known as <math>\mathbf{ES}(1+1)</math> (the next generation exists from the parent and a single child). Again, the mutation is the change of exactly one element in the string, which is a little bit unusual, but works fine. Again, the transition matrix is calculated, a pic is drawn and even a conclusion is made:

'' '''Results''' '': ''Figure 2(B) shows the active information per query for the ratchet strategy given different alphabet sizes and message lengths. Increasing the message length does not appear to significantly change the efficiency of active information extraction. However, increasing the alphabet size has a rather noticeable effect.''

Well, here the authors should really have used the exact solution instead of the numerical one: they came very close to it in an earlier paper (where they called this algorithm ''optimization by mutation with elitism''), and it was stated here at [[Conservation_of_Information_in_Search_-_Measuring_the_Cost_of_Success#Optimization_by_Mutation_With_Elitism:|RationalWiki]]:

The expected number of queries for this version of the <math>\mathbf{ES}(1+1)</math> is
:::<math>\mathbf{E}(Q) = (N-1) \cdot \mathcal{H}_{(1-\beta) L} \cdot L</math>
:::so that the average information per query is
:::<math>I_{\oplus}= \frac{\log(N)}{N-1}  \frac{1}{\mathcal{H}_{(1-\beta) L}}</math>
::::*<math>\beta\,</math>: rate of correct letters to start with
::::*<math> \mathcal{H}_{k} </math> k-th harmonic number
:::The effect of <math>\frac{\log(N)}{N-1}</math> is noticeable, the effect of of <math>\frac{1}{\mathcal{H}_{(1-\beta) L}}</math> less so.

BTW: in their earlier paper, Dembski et al. looked at an alphabet with two elements, <math>\{0,1\}</math>. They ''toggled'' exactly one bit - getting the mutation rate right, then.

*(C) '' '''Mutating Children With a Fixed Mutation Rate''' ''
[[File:Pop.size.queries-24.png|thumb|example for L=24, N &isin; {0,..,15}]]Again, a <math>\mathbf{ES}(1,k)</math> algorithm, this time the version which is generally agreed to be used in [[Dawkins weasel]]: the letters in the parent string are mutated with a fixed mutation rate for a couple of children, which are the next generation. The question which rate of mutation - and which size of a population - should be used for the case N=27 and L=28 has been answered - for instance - [http://dieben.blogspot.com/2009/10/which-parameters-did-dawkins-use-for.html here]. So the result of this section is - again - no surprise:

'' '''Results''' '': ''As illustrated in Figure 2(C), this algorithm has a slow decline in information per query until it suddenly collapses when the mutation rate becomes too high. If, for example, we are within a single character of identifying a phrase, then a mutation rate that gives on average, say, 10 mutations will take a long time to take the ﬁnal small step to perfection.''

*(D) '' '''Optimizing the Mutating Schedule for Children''' ''
Something - slightly - new. The mutation rate is not fixed, but evaluated in dependence of the value of the fitness function. Of course, optimizing the mutation probability has always been of interest.<ref>[[:File:GlobalPropertiesOfEvolution ProcessesAppendix.pdf|''Global Properties of Evolution Processes (Appendix)'' by H. J. Bremermann, M. Rogson, S. Salaff in ''Natural Automata and Useful Simulations, H.H. Pattee, E.A.Edelsack, L.Fein, and A.B.Callahan (eds), Spartan Books, Washington D.C, 1966'']]</ref> The concrete computation for every value from <math>{0,\dots, L}</math> seems to be quite labor-intensive, though.

== IV. Frequency of Occurrence Hamming Oracle Algorithm ==
While all algorithms described in the earlier section were random algorithms, here a deterministic one is given. It fares much better than the evolutionary algorithms, at least for the concrete oracle. But as stated above, evolutionary algorithms often work under different circumstances. Imagine for instance an oracle which doesn't state the number of correct letters in a phrase, but the length of the longest correct subphrase. Or the number of correct letters in a row counted from the beginning of the phrase. Or the product of the number of correct consonants and the number of correct vowels and spaces: The algorithms of (A), (B), (C) will still get the result, and (D), too - though it looses its advantages over the other three.
But the charmingly called ''FOOHO'' algorithm will fail.

But how does this ''FOOHO'' algorithm works? That's hard to know, as the authors described the initialization of the algorithm, and then stated:

''The remainder of the FOOHOA is best explained by example.''

Turns out: it isn't.

But let's approach the algorithm, starting with the <math>\mathbf{ES}(1+1)</math> with a single mutation per child, the ''ratchet strategy''. The interesting thing about evolutionary strategies: they don't preserve the history - the only memory a new generation can build upon is the current generation. That's of course at odds with the modeling in examinations like the ''No Free Lunch theorem'', which want to keep the searches finitely...

But the <math>\mathbf{ES}(1+1)</math> can be improved considerably if we allow for some external gathering of data (g.o.d.). That could be a list of the positions of letters which shouldn't altered anymore. Our algorithm <math>\mathbf{ES'}(1+1)</math> would then look as follows:

#start with an empty list and one random phrase
#create a child element by changing a letter at a position not on the g.o.d. list
#if the fitness value of the child differs from the value of the parent, at the position of the changed letter to the list
#if the fitness value equals the length of the phrase: STOP
#if the fitness value of the parent is smaller than the fitness value of the child, than the child is next generation's parent. Otherwise stick to the old parent.
#goto 2

If the first phrase includes <math>\lambda_0</math> correct letters, that <math>\mathbf{ES}(1+1)</math> needed <math>\mathbf{E_{\lambda_0}}(Q) = (N-1) \cdot \mathcal{H}_{L - \lambda_0} \cdot L</math> queries, while <math>\mathbf{ES'}(1+1)</math> takes <math>\mathbf{E_{\lambda_0}}(Q') \leq \lambda_0 + (N -1) \cdot (L - \lambda_0) </math>. (Why at most? Because <code>Step 4</code> will often be reached before all the <math>\lambda_0</math> correct letters have been tested.

But we can put a little bit more thought into it, and reduce it to <math>\mathbf{E_{\lambda_0}}(Q'') \leq \lambda_0 + \frac{N -1}{2} \cdot (L - \lambda_0) </math>. No additional memory is necessary, we just run through the letters not at random, but in a circular way: we chose our position for the letter and we take the next letter in alphabetical order (whatever this alphabet may look like). 

[[File:Epqi-1.png|thumb|expected number of queries depending on the number of correct letters in the start phrase]] As the number of correct letters in the start phrase follows the binomial distribution, we get

<math>\mathbf{E}(Q') \leq \sum_{\lambda_0 = 0}^L (\lambda_0 + (N-1)(L-\lambda_0)){L \choose \lambda_0} (\frac{1}{N-1})^{\lambda_0} (\frac{N-2}{N-1})^{L-\lambda_0}) </math> = <math>L\cdot(N-2+\frac{1}{N-1})</math> and - similarly - 

<math>\mathbf{E}(Q'')  \leq  \frac{L}{2} \cdot(N-2+\frac{2}{N-1})</math> 

How much of g.o.d. is necessary? If we randomly chose the letter which should be changed, we need a field of L values of <code>TRUE</code> or <code>FALSE</code>, if we start at the beginning of the phrase, we only have to remember the position we are currently working at...

[[File:Epqi-2.png|thumb|averaged active information as calculated for Fig. 5 in the paper]]Dembski et al. take it a step further - but they need more g.o.d.: in (L-1) steps, they create a list of the number of occurrences of the different letters. Instead of checking the letters in an alphabetical order, they start with the most frequent, and work they way down - if the example is understood correctly. This should improve the algorithm especially for <math>N \ll L</math>.

== V. Optimal Hamming Search: A Search for the Search ==
This should have been the main part of the paper. Unfortunately, it is a little bit short, and though some numbers are stated, no calculations are given. It could have profited from definitions of the basic terms, like ''search''. And some estimations would have be fine. So, it is just not much.

In the following the definitions introduced [[No Free Lunch Theorems|here]] are used.

A search in the sense of the paper equals a minimization of a function <math>f: \quad \Omega = \mathcal{X} \rightarrow \mathcal{Y}</math>, where <math>\mathcal{Y} \subset \mathbf{N}_0</math> - with <math>|f^{-1}(0)| =1\,</math>. The set of all these functions is <math>\Phi\,</math>.

Perhaps the most simple example for a c.u.p. set ''F'' of functions of this type is <math>F_1 = \{ \hat{\delta}_{\omega_0} | \omega_0 \in \Omega\}</math>, where:

<math>\hat{\delta}_{\omega_0}(\omega)</math><math> = \left\{\begin{matrix}
0  \quad:\quad \omega = \omega_0 \\ 1 \quad:\quad \omega \neq \omega_0\end{matrix}\right.</math>

These functions correlate with a search where the only answers of the ''oracle'' are ''found'' and ''not found''. Here, no clever search algorithm works, everything is at least as bad as blind search (without repetition, of course) - mathematically a result of the c.u.p property.

So, what's about the ''Hamming oracle''? For a alphabet <math>\Alpha</math> of N letters, and words of length L, we have <math>\mathcal{X}= \Omega </math><math> =\Alpha^L</math><math>= \{\alpha_1 \alpha_2 \dots \alpha_L | \alpha_i \in \Alpha\}</math>. Then <math>\mathcal{Y}=\{0,1, \dots L\}</math>. The set <math>F_2</math> of functions is given by <math>F_2= \{f_{\omega_0}|\omega_0 \in \Omega\}</math>

<math>f_{\omega_0}(\omega)</math><math> =  f_{\alpha^0_1 \alpha^0_2 \dots \alpha^0_L}(\alpha_1 \alpha_2 \dots \alpha_L)</math> <math>= |\{i|\alpha^0_i \neq \alpha_i, i = 1,..., L\}|</math>.

Interestingly <math>|F_1| = |F_2|\,</math>. But is <math>F_2</math> c.u.p., too? Absolutely not! In fact <math>|c.u.p (F_2)| \gg |F_2|</math>, where <math>c.u.p.(F_2)</math> denotes the smallest c.u.p. set of function which contains <math>F_2\,</math>. (How to determine <math>|c.u.p.(F_2)|\,</math>? Think about it! The functions in <math>f\,</math> in <math>F_2\,</math> are determined by their <math>L+1\,</math>level-sets, i.e., <math>f^{-1}(0), f^{-1}(1), \dots, f^{-1}(L)</math>. How big are these? <math>c_0 = |f^{-1}(0)| = 1\,</math>, <math>c_1 = |f^{-1}(1)| = (N-1) {L \choose 1}</math>, <math>c_k = |f^{-1}(k)| = (N-1)^k {L \choose k}</math>,<math>\dots</math>,<math>c_L = |f^{-1}(1)| = (N-1)^L\,</math>. Any function with level-sets of this size for the different values of the function is in the c.u.p. set a functions including <math>F_2\,</math>. So, there are

<math>|c.u.p (F_2)|</math> <math>= {|\Omega| \choose c_0} \cdot {|\Omega|-c_0 \choose c_1} \cdot \dots \cdot {|\Omega|-c_0-c_1-\dots-c_{L-1} \choose c_L}</math>

functions. BTW, the analogous calculation for <math>F_1</math> and the two level <math>\{0,1\}\,</math> shows again that <math>F_1</math> is c.u.p. : here, <math>c_0 = |f^{-1}(0)| = 1</math>, and <math>c_1 = |f^{-1}(1)| = |\Omega|-1</math>, therefore

<math>|c.u.p (F_1)|</math> <math>= {|\Omega| \choose 1}\cdot {|\Omega|-1 \choose |\Omega|-1} = |\Omega| = |F_1|</math>

Let's have a look how large the sets are which we were talking about. We'll follow the author's lead and look at alphabets of size 2 - 6, and words of length 1 - 6:
{|class="wikitable"
!&darr; #Alphabet N||1||2||3||4||5||6||&larr; Length of Word L
|-
!rowspan=3|2
|2||4||8||16||32||64
!<math>|\Omega|=|F_2|</math>
|-
|2||12||112||5.04 10<sup>7</sup>||1.38 10<sup>18</sup>||5.88 10<sup>40</sup>
!<math>|c.u.p(F_2)|</math>
|-
|2||32||17496||1.72 10<sup>10</sup>||1.49 10<sup>23</sup>||6.76 10<sup>50</sup>
!<math>|\Phi|</math>
|-
!rowspan=3|3
|3||9||27||81||243||749
!<math>|\Omega|=|F_2|</math>
|-
|3||630||7.83 10<sup>11</sup>||4.21 10<sup>43</sup>||1.44 10<sup>148</sup>||4.18 10<sup>482</sup>
!<math>|c.u.p(F_2)|</math>
|-
|3||2304||6.86 10<sup>13</sup>||1.18 10<sup>50</sup>||3.44 10<sup>171</sup>||2.27 10<sup>569</sup>
!<math>|\Phi|</math>
|-
!rowspan=3|4
|4||16||64||256||1024||4096
!<math>|\Omega|=|F_2|</math>
|-
|4||8.01 10<sup>4</sup>||2.95 10<sup>27</sup>||1.01 10<sup>132</sup>||1.06 10<sup>591</sup>||7.18 10<sup>2554</sup>
!<math>|c.u.p(F_2)|</math>
|-
|4||5.24 10<sup>5</sup>||7.32 10<sup>32</sup>||8.58 10<sup>155</sup>||1.14 10<sup>718</sup>||1.39 10<sup>3190</sup>
!<math>|\Phi|</math>
|-
!rowspan=3|5
|5||25||125||625||3125||15625
!<math>|\Omega|=|F_2|</math>
|-
|5||1.83 10<sup>7</sup>||2.50 10<sup>50</sup>||4.02 10<sup>300</sup>||3.13 10<sup>1680</sup>||1.86 10<sup>9101</sup>
!<math>|c.u.p(F_2)|</math>
|-
|5||4.19 10<sup>8</sup>||1.82 10<sup>61</sup>||3.03 10<sup>378</sup>||1.19 10<sup>2187</sup>||1.07 10<sup>12,162</sup>
!<math>|\Phi|</math>
|-
!rowspan=3|6
|6||36||216||1296||7776||46,656
!<math>|\Omega|=|F_2|</math>
|-
|6||6.61 10<sup>9</sup>||1.64 10<sup>81</sup>||1.07 10<sup>580</sup>||1.28 10<sup>3899</sup>||4.37 10<sup>25,433</sup>
!<math>|c.u.p(F_2)|</math>
|-
|6||1.23 10<sup>12</sup>||8.23 10<sup>104</sup>||6.03 10<sup>782</sup>||2.41 10<sup>5438</sup>||2.07 10<sup>36,309</sup>
!<math>|\Phi|</math>
|}

So, the functions based ''Hamming distance'' are only a minuscule part of all functions. And for these, the authors have calculated an optimal algorithm - at least for very small values of N and L. How so? They made an ''exhaustive inspection'' of all possible algorithms and looked for those who needed on average over all functions in <math>F_2\,</math> the least steps to identify the function. Here are the values of the paper:

{|class="wikitable"
!&darr; #Alphabet N||1||2||3||4||5||6||&larr; Length of Word L
|-
!2
|1.000||1.500||2.250||2.750||3.375||3.875
|-
!3
|1.667||2.337||2.889||3.469||-||-
|-
!4
|2.250||3.125||3.822||-||-||-
|-
!5
|2.800||3.281||-||-||-||-
|-
!6
|3.333||4.611||-||-||-||-
|}

The authors state that ''in general, a search for a search (S4S) is exponentially more computationally demanding than a search itself''. But this is of course the ''search for an optimal search''. In their paper ''A study of Some Implications of the No Free Lunch Theorem''<ref>Andrea Valsecchi and Leonardo Vanneschi (2008), ''A study of Some Implications of the No Free Lunch Theorem'', Applications of Evolutionary Computing, Volume 4974/2008, Springer Berlin/Heidelberg, pp. 634-635</ref> the authors Andrea Valsecchi and Leonardo Vanneschi propose an algorithm to look for a quite good ''search''. The next table is based on an implementation of their idea:

{|class="wikitable"
!&darr; #Alphabet N||1||2||3||4||5||6||&larr; Length of Word L
|-
!2
|''1.000''||''1.500''||''2.250''||2.875||3.500||4.013
|-
!3
|''1.667''||''2.333''||3.037||3.827||4.407||4.8779
|-
!4
|''2.250''||''3.125''||3.938||4.727||5.389||5.948
|-
!5
|''2.800''||3.880||4.776||5.608||6.369||7.037
|-
!6
|''3.333''||''4.611''||5.588||6.488||7.324||-
|}

(''italic'': same value as in previous table)

The values are generally worse than those of Dembski et al.'s ''exhaustive inspection'', but the algorithm to find them has only computational complexity of <math>\Theta(|\mathcal{X}| |F|^4)</math><math>=\Theta(|\Omega|^5)\,</math>.

== What has this all to do with the theory of evolution or intelligent design ==
Short answer: Nothing.

Dembski announced this article as ''deconstructing the Dawkin's weasel''. Just one question: which algorithms were the easiest to program - and the easiest to evaluate? Yep, the weasel-type ones. Didn't take much intelligence to realize them, and that's—IMO—the main result.

Furthermore, [[Social Darwinism|evolution isn't about the ''survival of the fittest'']]; it's about ''survival of the fittest present''—and absolutely not ''survival of the theoretically fittest''.

So, it's nice to see the lower bounds for the search algorithms. And though evolution brought forth optimal solutions for some problems—which are used in {{wpl|bionics}}—often, a solution is only a local optimum and not a global one (stellar example: the {{wpl|Evidence_of_common_descent#Recurrent_laryngeal_nerve_in_giraffes|laryngeal nerve in giraffes}}).

== VI. Conclusions ==
''By exploring a variety of algorithms we have demonstrated hat the simple Hamming oracle can be used with surprisingly different degrees of efficiency as measured by query count. The FOO Hamming oracle algorithm manages to extract approximately one bit of information per query indicating hat the oracle can be a significant source of information. In comparison, evolutionary search as modeled by Markov processes uses the Hamming oracle inefficiently. The success of a searches derives not from any intrinsic property of the search algorithm, but from the information available from the oracle as well as the efficiency of the search algorithm in the extraction of that information. A high level interactive simulation of algorithms showing their varying effectiveness in extracting active information using a Hamming oracle is available on line at www.evoinfo.org.''

That doesn't seem to be so surprising. Amusingly, it is a consequence of Dembski's favourite ''No Free Lunch'' theorem, that an algorithm which outperforms all others for a certain oracle will be less efficient for other oracles. And it's a strength of simply-built evolutionary algorithms that they work well with a great class of sensible oracles.

==See also==
*[[Conservation of Information in Search - Measuring the Cost of Success]]
*[[The Search for a Search - Measuring the Information Cost of Higher Level Search]]
*[[Uncommon Descent]]
*[[Barry Arrington]]

==References==
{{reflist}}

{{crebox}}

[[Category:Side-by-side articles]]
[[Category:Creationism]]
[[Category:Documents]]
[[Category:Refutations]]

Categories: Side-by-side articles, Creationism, Documents, Refutations