Towards a Complexity Theory of Randomized

Search Heuristics: Ranking-Based Black-BoxComplexity

Benjamin Doerr and Carola Winzen�

Max-Planck-Institut fur Informatik, 66123 Saarbrucken, Germany

Abstract. Randomized search heuristics are a broadly used class ofgeneral-purpose algorithms. Analyzing them via classical methods of the-oretical computer science is a growing field. A big step forward wouldbe a useful complexity theory for such algorithms. We enrich the twoexisting black-box complexity notions due to Wegener and other authorsby the restrictions that not actual objective values, but only the relativequality of the previously evaluated solutions may be taken into accountby the algorithm. Many randomized search heuristics belong to this classof algorithms. We show that the new ranking-based model gives more re-alistic complexity estimates for some problems, while for others the lowcomplexities of the previous models still hold.

1 Introduction

Randomized search heuristics are general purpose algorithms to solve optimiza-tion problems. They include fancy approaches like evolutionary algorithms andant colony optimization, but also classical approaches like random search orrandomized hill-climbers.

In practice, randomized search heuristics often are surprisingly successful (andthus extensively used). They have the additional advantage that not too muchunderstanding of the optimization problem at hand is needed, and that onceimplemented, they can easily be re-used for similar problems.

One of the difficulties in using such heuristics is that it is very hard to pre-dict which problems are easy for a suitable heuristic and which are generallyintractable for randomized search heuristics. There has been some theoreticalwork in the last 20 years, pioneered by the work of Ingo Wegener.

This work mostly lead to results for particular problems and particular heuris-tics, many of which disproved what was common believe of practitioner in thisarea. For example, Horn, Goldberg, and Deb [HGD94] showed that there areunimodal functions f : {0, 1}n → R (that is, each search point x ∈ {0, 1}n apartfrom the optimum has a Hamming neighbor with strictly better f -value) suchthat many commonly used search heuristics need time exponential in n to findthe optimum of f .� Carola Winzen is a recipient of the Google Europe Fellowship in Randomized Algo-

rithms, and this work is supported in part by this Google Fellowship.

A. Kulikov and N. Vereshchagin (Eds.): CSR 2011, LNCS 6651, pp. 15–28, 2011.c© Springer-Verlag Berlin Heidelberg 2011

16 B. Doerr and C. Winzen

Still, for a broader understanding of what are easy and difficult problems, acomplexity theory similar to what exists in classical algorithmics would be highlydesirable, also for randomized search heuristics. The seminal paper by Droste,Jansen, and Wegener [DJW06], introducing the so-called black-box model, ap-pears to be the first attempt to start such a complexity theory in the randomizedsearch heuristics community. Earlier related work exists, e.g., [LTT89], [HK78],and [Ald83].

The paradigm that randomized search heuristics should ideally be problem-independent implies that the only way a randomized search heuristics can obtainproblem-specific information is by evaluating a solution candidate. This evalua-tion is done by an oracle that returns the objective value, but reveals no furtherinformation on the objective function. An algorithms that has no access to the ob-jective function (and thus the optimization problem to be solved) other than byquerying the objective value from such an oracle, is called a black-box algorithm.

Given a class of functions F , Droste et al. define the black-box complexity ofF to be the the minimum (taken over all black-box algorithms) expected numberof function evaluations needed to optimize any function f ∈ F (minimum worst-case runtime). This number, naturally, is a lower bound on the run time of anyrandomized search heuristics for the class F , including evolutionary algorithms,ant colony approaches, simulated annealing, et cetera.

Unfortunately, it turned out that allowing all black-box algorithms leads tosometimes unexpectedly small complexities (obtained by not very sensible algo-rithms). As a trivial example, note that the black-box complexity of any classof functions F = {f} consisting just of a single objective function, is one —as certified by the algorithm that simply queries the optimum of f . This andfurther examples suggest that a restriction of the class of algorithms might leadto more meaningful results.

A major step towards this direction is the work by Lehre and Witt [LW10].They introduce a so-called unbiased black-box model, which, among other restric-tions, requires that all search points queried by the algorithms must be obtainedfrom previous or random search points by so-called unbiased variation operators,see Section 2 for the full details. This in particular restricts an unwanted use ofknowledge on the function class F . It also leads to a lower bound of Ω(n log n)for the complexity of all single-element classes F = {f}, f having a unique globaloptimum, when only unary operators are allowed. This is, indeed, the typical runtime of simple search heuristics like randomized hill-climbers on simple functionclasses like monotone functions.

In this work, we shall argue that the unbiased model of Lehre and Witt isstill not restrictive enough. Let f : {0, 1}n → R, x �→ ∑n

i=1 2i−1xi be the binary-value function of the bit-string x. Let F be the the class of functions consisting off and all functions obtained from f by permuting the order of the bit positionsand by flipping the meaning of the values of some bit-positions. Then, as we shallshow in this paper, the unbiased black-box complexity of F is only �log2 n�+ 2.The corresponding algorithm (see Section 5) heavily exploits particular objectivevalues which it learns from its queries.

Towards a Complexity Theory of Randomized Search Heuristics 17

This is what most randomized search heuristics do not do. They typicallyonly use the objective values to compare search points. We define the black-box complexity notion referring to this paradigm by allowing the algorithms toonly exploit the relative ranking of the search points queried so far. In otherwords, throughout the optimization the algorithms knows for any two alreadyqueried search points x and y no more than whether f(x) < f(y), f(x) = f(y)or f(x) > f(y). In particular, it does not know the true values of f(x) and f(y).Still, this model captures many commonly used randomized search heuristics.

We show that our proposed model solves some drawbacks of the previousmodels. For example, for the binary-value function class introduced above, thisranking-based black-box complexity is of order Θ(n) instead of only O(log n)without the ranking restriction. In the Θ(n) statement, the lower bound proofis clearly the more interesting one. The upper bound is easily verified by asimple hill-climber that, in arbitrary order, changes a single bit-value of thecurrent solution and accepts the new solution if it is better than the previousone. In summary, we see that for this function class, the ranking-based black-boxcomplexity seems to give us a more useful complexity measure than the previousapproaches.

We also analyze a second class commonly regarded in this context. Let F bethe class of all (so-called onemax-) functions fz : {0, 1}n → R; x �→ n − ‖x −z‖1, z ∈ {0, 1}. Hence, fz(x) is just the number of bit positions x and z agreeon. Here, all previous black-box models showed a complexity of Θ(n/ log n),which again is sightly smaller than what one would expect. The proofs of theseresults again heavily exploit that the oracle returns the precise fitness value.In spite of this, we still find a black-box algorithm in our ranking-based modelthat solves the problem with Θ(n/ log n) queries. We are currently not sureif this should be interpreted in the way that this function class is easier tooptimize, or in the way that the ranking-based model still allows too powerfulalgorithms.

Though we claim that in this paper we introduce ranking-based black-boxcomplexity, the work by Droste et al. [DJW06] implicitly contains a result onthis as well. Droste et al. give a lower bound of Ω(n/ log(n)) for the unre-stricted black-box complexity of the class of all functions g ◦ f , where g : R → R

is strictly monotone increasing and f is a binary-value function. As we arguelater, ranking-based complexity is the same as classical complexity after allow-ing arbitrary strictly monotone perturbations of the objective values. For thisreason, Droste et al. implicitly show that the ranking-based black-box com-plexity of the binary-value functions is Ω(n/ log n), which we now improve tothe sharp bound of Ω(n). Via the same argumentation, the conference ver-sion [DJTW03] of [DJW06] also shows that the ranking-based complexity ofthe leadingones class (defined in Section 6) is between n/2−o(n) and n+1. Ourlower-bound proof for the binary-value class also applies to this class, improvingthe lower bound from n/2−o(n) to n−2, which is sharp apart from the additiveterm.

18 B. Doerr and C. Winzen

2 Notation and Previous Black-Box Models

In this section, we give a brief overview of two previous black-box models, theunrestricted black-box model by Droste, Jansen and Wegener [DJW06] and themore recent unbiased black-box model by Lehre and Witt [LW10].

Let us first fix the notations used frequently throughout the paper.

2.1 Notation

The positive integers are denoted by N. For k ∈ N, we abbreviate [k] :={1, . . . , k}. Similarly, we define [0..k] := [k] ∪ {0}. For k, � ∈ N we write[k ± �] := [k − �, k + �] ∩ Z.

Let n ∈ N. For a bit string x = x1 . . . xn ∈ {0, 1}n, we denote by x the bitwisecomplement of x (i.e., for all j ≤ n we have xj = 1 − xj).

If x, y ∈ {0, 1}n, we obtain the bit string x ⊕ y by setting, for each j ∈ [n],(x⊕y)i := 1 if xi = yi and (x⊕y)i := 0 if xi = yi. That is, ⊕ denotes the bitwiseexclusive-or. We use the shorthand |x|1 for the number of ones in the bit stringx, i.e., |x|1 =

∑ni=1 xi.

If f is a function and S a set, we write f(S) := {f(s) ; s ∈ S}. We write idS

for the identity function of S, i.e., idS(s) = s for all s ∈ S. For n ∈ N, the setSn contains all permutations of [n]. For σ ∈ Sn and x ∈ {0, 1}n we abbreviateσ(x) := xσ(1) . . . xσ(n).

Lastly, we denote by log the natural logarithm to base e := exp(1). If we referto a different base, we indicate this in the subscript, e.g., we write log2 for thebinary logarithm.

All asymptotic notation (Landau symbols, big-Oh notation) will be with re-spect to n, which typically denotes the dimension of the search space {0, 1}n.

2.2 Unrestricted and Unbiased Black-Box Model

As mentioned in the introduction, we aim at continuing the development of acomplexity theory for randomized search heuristics. Usually, the complexity of aproblem is measured by the performance of the best algorithm out of some classof algorithms (e.g., all those algorithms which can be implemented on a Turingmachine [GJ90], [Hro03]).

What distinguishes randomized search heuristics from classical algorithms isthat they are problem-independent. As such, the only way they obtain informa-tion about the problem to be solved is by learning the objective value of possiblesolutions (“search points”). To ensure this problem-independence, one usuallyassumes that the objective function is given by an oracle or as a black-box. Usingthis oracle, the algorithm may query the objective value of all possible solutions,but any such query does only return this search point’s objective value and noother information about the objective function.

For simplicity, we shall restrict ourselves to real-valued objective functionsdefined on the set {0, 1}n of bit-strings of length n. This is motivated by the factthat many evolutionary algorithms use such a representation.

Towards a Complexity Theory of Randomized Search Heuristics 19

Naturally, we do allow that the algorithms use random decisions. From theblack-box concept, it follows that the only type of action the algorithm mayperform is, based on the objective values learned so far, deciding on a probabilitydistribution on {0, 1}n, sampling a search point x ∈ {0, 1}n according to thisdistribution, and querying its objective value from the oracle. This leads to thescheme of Algorithm 1, which we call an unrestricted black-box algorithm.

As performance measure of a black-box algorithm we take the number ofqueries to the oracle performed by the algorithm until it first queries an opti-mal solution. We call this the run time, or optimization time, of the black-boxalgorithm. This is justified by the observation that in typical applications ofrandomized search heuristics, the evaluation of the fitness of the search points ismore costly than the generation of new search points. Since we are mainly talkingabout randomized algorithms, we regard the expected number of queries.

We can now follow the usual approach in complexity theory. Let F be a classof real-values functions defined on {0, 1}n. The complexity of an algorithm Afor F is the maximum expected run time of A on a function f ∈ F (worst-caserun time). The complexity of F with respect to a class A of algorithms is theminimum (“best”) complexity among all A ∈ A for F . The unrestricted black-boxcomplexity of F is the complexity of F with respect to the class of all black-boxalgorithms. This is the black-box complexity as introduced by Droste, Jansenand Wegener [DJW06].

Algorithm 1. Scheme of an Unrestricted Black-Box Algorithm

1 Initialization: Sample x(0) according to some probability distribution p(0) on

{0, 1}n. Query f(x(0)).2 Optimization: for t = 1, 2, 3, . . . until termination condition met do

3 Depending on((x(0), f(x(0))), . . . , (x(t−1), f(x(t−1)))

), choose a probability

distribution p(t) on {0, 1}n.4 Sample x(t) according to p(t), and query f(x(t)).

It is easily seen that the class of all black-box algorithms is very powerful. Forexample, for any function class F = {f} consisting of one single function, theunrestricted black-box complexity of F is 1—the algorithm that simply queriesan optimal solution of f as first action shows this bound.

These drawbacks of the unrestricted black-box model inspired Lehre andWitt [LW10] to introduce a more restrictive black-box model, where algorithmsmay generate new solution candidates only from random or previously generatedsearch points and only by using unbiased operators. Still the model contains mostof the commonly studied search heuristics, such as many (μ +λ) and (μ, λ) evo-lutionary algorithms, simulated annealing algorithms, the Metropolis algorithm,and the Random Local Search algorithm.

20 B. Doerr and C. Winzen

Definition 1 (k-ary unbiased variation operator). Let k ∈ N. A k-ary un-biased distribution D(. | y(1), . . . , y(k))y(1),...,y(k)∈{0,1}n is a family of probabilitydistributions over {0, 1}n such that for all inputs y(1), . . . , y(k) ∈ {0, 1}n thefollowing two conditions hold.

(i)∀x, z ∈ {0, 1}n : D(x | y(1), . . . , y(k)) = D(x ⊕ z | y(1) ⊕ z, . . . , y(k) ⊕ z) and

(ii)∀x ∈ {0, 1}n ∀σ ∈ Sn : D(x | y(1), . . . , y(k)) = D(σ(x) | σ(y(1)), . . . , σ(y(k))) .

We refer to the first condition as ⊕-invariance and to the second as permutationinvariance. An operator sampling from a k-ary unbiased distribution is called ak-ary unbiased variation operator.

Note that the only 0-ary unbiased distribution over {0, 1}n is the uniform one. 1-ary, also called unary operators are sometimes referred to as mutation operators,in particular in the field of evolutionary computation. 2-ary, also called binaryoperators are often referred to as crossover operators. If we allow arbitrary arity,we call the corresponding model the ∗-ary unbiased black-box model.

k-ary unbiased black-box algorithms can now be described via the schemeof Algorithm 2. The k-ary unbiased black-box complexity of some class of func-tions F is the complexity of F with respect to all k-ary unbiased black-boxalgorithms.

Algorithm 2. Scheme of a k-ary Unbiased Black-Box Algorithm

1 Initialization: Sample x(0) ∈ {0, 1}n uniformly at random and query f(x(0)).2 Optimization: for t = 1, 2, 3, . . . until termination condition met do

3 Depending on(f(x(0)), . . . , f(x(t−1))

)choose up to k indices

i1, . . . , ik ∈ [t − 1] and a and a k-ary unbiased distributionD(. | x(i1), . . . , x(ik)).

4 Sample x(t) according to D(. | x(i1), . . . , x(ik)) and query f(x(t)).

Note that for all k ≤ � each k-ary unbiased black-box algorithm is containedin the �-ary unbiased black-box model.

Lehre and Witt [LW10] proved, among other results, that all functions with asingle global optimum have a unary unbiased black-box complexity of Ω(n log n).For several standard test problems this bound is met by different unary random-ized search heuristics, such as the (1 + 1) EA or the Random Local Search algo-rithm. Recall that, as pointed out above, the unrestricted black-box complexityof any such function is 1. For results on higher arity models refer to the work ofDoerr et al. [DJK+10].

3 The Ranking-Based Black-Box Model

It has been commented by Hansen [Han10] that many standard randomizedsearch heuristics do not take advantage of knowing the exact objective values.

Towards a Complexity Theory of Randomized Search Heuristics 21

Rather, they create new search points based on the relative objective values ofpreviously queried search points. That is, after having queried t fitness valuesf(x(1)), . . . , f(x(t)), they rank the corresponding search points x(1), . . . , x(t) ac-cording to their relative fitness. The selection of input individuals x(i1), . . . , x(ik)

for the next variation operator is based solely on this ranking. We define rankingas follows.

Definition 2. Let S be a set, let f : S → R be a function, and let C be asubset of S. The ranking ρ of C with respect to f assigns to each element c ∈ Cthe number of elements in C with a smaller f -value plus 1, formally, ρ(c) :=1 + |{c′ ∈ C ; f(c′) < f(c)}|.Note that two elements with the same f -value are assigned the same ranking.

As discussed above, many randomized search heuristics do only use the rank-ing of the search points seen so far. Therefore, we restrict the two black-boxmodels which we introduced in the previous section to black-box algorithmsthat use no other information than this ranking.

Unrestricted Ranking-Based Black-Box Model. The unrestricted ranking-based black-box model can be described via the scheme of Algorithm 1 wherewe replace the third line by “Depending on the ranking of {x(0) . . . , x(t−1)} withrespect to f , choose a probability distribution p(t) on {0, 1}n.”

Unbiased Ranking-Based Black-Box Model. For the definition of the un-biased ranking-based model we consider the scheme of Algorithm 2 and replacethe third line by “Depending on the ranking of {x(0) . . . , x(t−1)} with respect tof , choose up to k indices i1, . . . , ik ∈ [t − 1] and a k-ary unbiased distributionD(. | x(i1), . . . , x(ik)).”

Both ranking-based black-box models capture many common search heuris-tics, such evolutionary algorithms using elitist selection, ant colony optimizationalgorithms, and the Random Local Search algorithm. They do not include algo-rithms like simulated annealing algorithms, threshold accepting algorithms, orevolutionary algorithms using fitness proportional selection.

The ranking restriction in both the unrestricted and unbiased ranking-basedmodel can equivalently be implemented by applying an unknown strictly mono-tone perturbation to the fitness values. That is, we assume there is a strictlymonotone function1 g : R → R unknown to the algorithm. Whenever the algo-rithm queries a search point x, the oracle only returns g(f(x)) (instead of theobjective value f(x)). Again we adopt the worst-case view, that is, the perfor-mance of an algorithms is the worst among all f ∈ F and all strictly monotonefunctions g : R → R.

We sometimes refer to this model as the (unrestricted or unbiased, respec-tively) monotone black-box model. In particular for upper bound proofs, thismodel is often more convenient to work with.1 Recall that a function g : R → R is said to be strictly monotone if for all α < β we

have g(α) < g(β).

22 B. Doerr and C. Winzen

4 Ranking-Based Black-Box Complexity of OneMax

A classical easy test function in the theory of randomized search heuristics isthe function OneMax, which simply counts the number of 1-bits, OneMax(x)=

∑ni=1 xi. The natural generalization of this particular function to a non-trivial

class of functions is as follows.

Definition 3 (OneMax function class). For z ∈ {0, 1}n let Omz : {0, 1}n →[0..n], x �→ Omz(x) = |{i ∈ [n] ; xi = zi}|. The string z = argmaxOmz is calledthe target string of Omz. Let OneMaxn := {Omz ; z ∈ {0, 1}n} be the set of allgeneralized OneMax functions.

In [DJK+10], the authors prove that the k-ary unbiased black-box complexityof OneMaxn is O(n/ log k). The following theorem shows that we can achievethe same bound in the (much weaker) unbiased ranking-based model.

Theorem 1. For each k ≤ n, the k-ary unbiased ranking-based black-box com-plexity of OneMaxn is O(n/ log k).

For k = Θ(n) this statement is asymptotically optimal since already for theunrestricted black-box complexity a lower bound of Ω(n/ log n) has been shownby Anil and Wiegand [AW09].

The proof of Theorem 1 is quite technical. Due to space limitations, we onlypresent a short overview here. Full proofs can be found in [DW11].

The main point of the proof is showing that the statement holds for k = n.We then generalize this case for arbitrary values of k. To this end, we derivefrom the case k = n that one can independently optimize blocks of length kin O(k/ log k) iterations, using k-ary unbiased variation operators only. Sincethere are �n/k� such blocks of length k, the desired O(n/ log k) bound followsby sequential optimization of these blocks.

The proof of the case k = n again is divided into several steps. In the follow-ing description, all Greek symbols are constants and all statements hold withprobability at least 1 − o(n−λ). We work in the monotone model, the unknownmonotone perturbation is denoted by g, the unknown objective function by Omz .

First, we show by simple Chernoff bound arguments that after drawingαn/ log n samples from {0, 1}n uniformly at random, we have hit each fit-ness value � ∈ [n

2 ± κ√

n] at least once and that we have at least 12 (1 −

2e−2κ2)αn log−1 n samples x with objective value Omz(x) ∈ [n

2 ± κ√

n].Recall that we have not actually seen these objective values since they are hiddenby the strictly monotone perturbation g.

Let x be a search point such that g(Omz(x)) is the median of the sampled ob-jective values. Then Omz(x), though unknown, lies in [n

2 ± logn]. Consequently,Omz(x) also lies in [n

2 ± log n]. In particular, both g(Omz(x)) and g(Omz(x)) liein the interval g

([n2 ± κ

√n]

), which is completely covered by the samples. Thus,

a point y with g(Omz(y)) right in the middle of g(Omz(x)) and g(Omz(x))satisfies Omz(y) = n

2 . Hence, by querying g(Omz(x)) we exhibited one exactOmz-value, which in turn tells us the exact Omz-values of all samples x withg(Omz(x)) ∈ g

([n2 ± κ

√n]

).

Towards a Complexity Theory of Randomized Search Heuristics 23

Lastly, we compute that there exists no y = z such that Omz(x) = Omy(z)for all samples x with Omz(x) ∈ [n

2 ±κ√

n]. In addition, the unique target stringz can be created via an unbiased operation.

Putting everything together, we have defined an (unbiased) algorithm whichidentifies and creates the target string z in αn/ logn + 2 iterations.

5 The Different Black-Box Complexities of BinaryValue

In the previous section, we have seen that the additional ranking restriction didnot increase the black-box complexity of the OneMax functions class. In thissection, we show an example where the two kinds of complexities greatly differ.Surprisingly, another simple class of classical test functions does the job, namelythe class of generalized binary-value functions.

The binary-value function Bv is defined via Bv(x) =∑n

i=1 2i−1xi, that is,it assigns to each bit string its binary value. As before, we generalize this sin-gle function to a function classes BinaryValuen (and BinaryValue∗

n), whichare the ⊕-invariant (⊕- and permutation-invariant) closure of the standard Bvfunction.

In the following we denote by δ the Kronecker symbol, i.e., for any two num-bers k, � ∈ N0 we have δ(k, �) = 1 if k = � and δ(k, �) = 0 otherwise.

Definition 4 (BinaryValue function class). For z ∈ {0, 1}n and σ ∈Sn, we define the function Bvz,σ : {0, 1}n → N0, x �→ Bv(σ(x ⊕z)) =

∑ni=1 2i−1δ(xσ(i), zσ(i)). We set Bvz := Bvz,id[n]. We further define

the classes BinaryValuen := {Bvz ; z ∈ {0, 1}n} and BinaryValue∗n :=

{Bvz,σ ; z ∈ {0, 1}n, σ ∈ Sn}. If f ∈ BinaryValuen (f ∈ BinaryValue∗n),

there exist exactly one z ∈ {0, 1}n (and exactly one σ ∈ Sn) such that f = Bvz

(f = Bvz,σ). Since z = arg maxBvz (z = argmaxBvz,σ), we call z the targetstring of f . Similarly, we call σ the target permutation of Bvz,σ.

We show that the unbiased black-box complexity of BinaryValue∗n is

O(log n), cf. Theorem 2, whereas both ranking-based black-box complexities ofBinaryValuen are Θ(n), cf. Theorem 3.

Let us begin with the upper bound for the unbiased black-box complexity.

Theorem 2. The ∗-ary unbiased black-box complexity of BinaryValue∗n (and

thus, the one of BinaryValuen) is at most �log2 n� + 2.

The main reason why the black-box complexity of BinaryValue∗n is much lower

than the one of OneMaxn is that each BinaryValue-function has 2n differentfunction values. Hence, each query reveals much more information about theunderlying objective function. The complete proof can be found in [DW11].

We devote the remainder of this section to the proof of the following result.

Theorem 3. The unrestricted ranking-based black-box complexity ofBinaryValuen and BinaryValue∗

n is larger than n − 2.

24 B. Doerr and C. Winzen

As discussed in the introduction, Droste, Jansen, and Wegener [DJW06] implic-itly showed a lower bound of Ω(n/ log n) for the setting of Theorem 3. Our lowerbound of n − 2 is almost tight. For the unrestricted ranking-based complexity,[DJW06] again implicitly provide an upper bound of n + 2. For the unbiasedcase, previous work by Doerr et al. [DJK+10] immediately yields the following.

Corollary 1. For all k ≥ 2, the k-ary unbiased ranking-based black-box com-plexity of BinaryValuen and BinaryValue∗

n is at most 2n.

To derive the lower bound in Theorem 3, we employ Yao’s minimax princi-ple [Yao77].

Theorem 4 (Yao’s Minimax Principle, formulation following [MR95]).Let Π be a problem with a finite set I of input instances (of a fixed size) permit-ting a finite set A of deterministic algorithms. Let p be a probability distributionover I and q be a probability distribution over A. Then,

minA∈A

E[T (Ip, A)] ≤ maxI∈I

E[T (I, Aq)] ,

where Ip denotes a random input chosen from I according to p, Aq a randomalgorithm chosen from A according to q and T (I, A) denotes the running timeof algorithm A on input I.

We apply Yao’s minimax principle in our setting as follows. We first show thatin the ranking-based black-box model, any deterministic algorithm needs anexpected number of at least n − 2 iterations to optimize Bvz, if Bvz is takenfrom BinaryValuen uniformly at random. Theorem 4 then implies that for anyrandomized algorithm A there exist at least one instance Bvz ∈ BinaryValuen

such that it takes, in expectation, at least n − 2 iterations for algorithm A tooptimize Bvz . This implies Theorem 3.

The crucial observation is that when optimizing Bvz with a ranking-basedalgorithms, then from t samples we cannot learn more than t − 1 bits of thehidden bit-string z. This is easy to see for two samples x, y. If Bvz(x) > Bvz(y),we see that xk = zk = yk, where k := max{j ∈ [n] ; xj = yj}, but all other bitsof z can be arbitrary. That t samples do not reveal

(t2

)bits, but only t − 1, is a

consequence of the following combinatorial lemma (for the proof confer [DW11]).

Lemma 1. Let t ∈ [n] and let x(1), . . . , x(t) be t pairwise different bit strings.For every pair (i, j) ∈ [t]2 we set �i,j := max{k ∈ [n] ; x

(i)k = x

(j)k }, the largest

bit position in which x(i) and x(j) differ. Then |{�i,j ; i, j ∈ [t]}| ≤ t − 1.

We are now ready to prove Theorem 3.

Proof (of Theorem 3). It is easily seen that the set A of all deterministic algo-rithms on BinaryValuen is finite, if we restrict our attention to those algo-rithms which stop querying search points after the n-th iteration.

As mentioned above, we equip BinaryValuen with the uniform distribution.Let Bvz ∈ BinaryValuen be drawn uniformly at random and let A ∈ A be

Towards a Complexity Theory of Randomized Search Heuristics 25

a (deterministic) algorithm. In the following, we show that prior to the t-thiteration, the set of still possible target strings has size at least 2n−t+1 andthat all of these target strings have the same probability to be the desired targetstring (A). Consequently, the probability to query the correct bit string in the t-th iteration, given that the algorithm has not found it in a previous iteration, is atmost 2−n+t−1. This yields that the expected number of iterations E[T (Bvz, A)]until algorithm A queries the target string z can be bounded from below by

n∑

i=1

i · Pr[A queries z in the i-th iteration] ≥n∑

i=1

i · 2−n+i−1

=n∑

i=1

(n − i + 1) 2−i = (n + 1)n∑

i=1

2−i −n∑

i=1

i 2−i . (1)

A simple, but nonetheless very helpful observation shows

n∑

i=1

i 2−i =n∑

i=1

2−i +n∑

i=1

(i − 1) 2−i

= (1 − 2−n) + 2−1n∑

i=1

(i − 1) 2−(i−1) = (1 − 2−n) + 2−1n−1∑

i=1

i 2−i ,

yielding∑n

i=1 i 2−i = 2(1 − 2−n) − n2−n = 2 − (n + 2)2−n .Plugging this into (1), we obtain

E[T (Bvz, A)] ≥ (n + 1)(1 − 2−n) − (2 − (n + 2)2−n) > n − 2 .

This proves minA∈A E[T (Bvz , A)] > n− 2. Since any randomized ranking-basedblack-box algorithm A can be modeled by randomly choosing a determinis-tic one Aq according to a suitable distribution q and then executing the lat-ter, Yao’s minimax principle (Theorem 4) implies maxz∈{0,1}n E[T (Bvz , Aq)] ≥minA∈A E[T (Bvz, A)] > n− 2. That is, the ranking-based black-box complexityof BinaryValuen is larger than n − 2.

It remains to prove (A). Let t ≤ n and let x(1), . . . , x(t) be the search pointswhich have been queried by the algorithm in the first t iterations. All the algo-rithm has learned about x(1), . . . , x(t) is the ranking of these bit strings, i.e.,it knows for all i, j ∈ [t] whether Bvz

(x(i)

)> Bvz

(x(j)

), or Bvz

(x(i)

)<

Bvz

(x(j)

), or Bvz

(x(i)

)= Bvz

(x(j)

). Note that Bvz

(x(i)

)= Bvz

(x(j)

)im-

plies x(i) = x(j). Thus, this case can be disregarded as one cannot learn anyadditional information by querying the same bit string twice.

As in Lemma 1 we set, for all i, j ∈ [t], �i,j := max{k ∈ [n] ; x(i)k = x

(j)k } and

L := {�i,j ; i, j ∈ [t]}.Let � ∈ L and let i, j ∈ [t] such that max{k ∈ [n] ; x

(i)k = x

(j)k } = �. We

can fix z� = x(i)� if Bvz

(x(i)

)> Bvz

(x(j)

), and we fix z� = x

(j)� if Bvz

(x(i)

)<

Bvz

(x(j)

). That is, we can fix |L| bits of z.

26 B. Doerr and C. Winzen

Statement (A) follows from observing that for every single bit string z′ withz′� = z� for all � ∈ L the function Bvz′ yields exactly the same ranking as Bvz .Hence, all such z′ are possible target strings. Since there is no way to differentiatebetween them, all of them are equally likely to be the desired target string.

Furthermore, it holds by Lemma 1 that |L| ≤ t − 1. This shows that, at theend of the t-th iteration, there are at least 2n−(t−1) possible target strings. Itfollows from Lemma 1 that either the algorithm has queried at most one of thesepossible target strings already, or |L| < t − 1. Consequently, prior to executingthe (t + 1)-st iteration, there are at most 2n−(t−1) − 1 > 2n−t bit strings whichare equally likely to be the desired target string. This proves (A). ��Note that already a much simpler proof, also applying Yao’s minimax principle,shows the following general lower bound.

Theorem 5. Let F be a class of functions such that each f ∈ F has a uniqueglobal optimum and such that for all z ∈ {0, 1}n there exists a function fz ∈ Fwith z = arg max fz. Then the unrestricted ranking-based black-box complexityof F is Ω(n/ log n).

6 Ranking-Based Black-Box Complexity of LeadingOnes

The proof ideas of the lower bound in the previous section can also be appliedto another classical class of test functions called LeadingOnes. This closes agap left open in [DJTW03].

For every bit string x, LeadingOnes(x) is defined to be the length of thelongest prefix of ones. As before, we define two generalized classes of Leadin-gOnes functions.

Definition 5 (LeadingOnes function class). Let n ∈ N. For any z ∈ {0, 1}n

let Loz : {0, 1}n → N, x �→ max{i ∈ [0..n] ; xi = zi}, the length of the maximaljoint prefix of x and z. Let LeadingOnesn be the collection of all such functions,i.e., LeadingOnesn := {Loz ; z ∈ {0, 1}n}.

For z ∈ {0, 1}n and σ ∈ Sn we set Loz,σ : {0, 1}n → N, x �→ max{i ∈[0..n] ; xσ(i) = zσ(i)}, the maximal joint prefix of x and z with respect to σ.The set LeadingOnes∗n contains all such functions, i.e., LeadingOnes∗n :={Loz,σ ; z ∈ {0, 1}n, σ ∈ Sn}.As discussed in the last paragraph of the introduction, Droste et al. in theconference version [DJTW03] of paper [DJW06] implicitly show that the ranking-based black-box complexity of LeadingOnesn is at least n

2 − o(n) and at mostn + 1. Using the same methods as for BinaryValuen, we improve the lowerbound to n − 2 (noting that we did not try to optimize the additive gap of 3).

Theorem 6. The unrestricted ranking-based black-box complexity ofLeadingOnesn (and thus, the unrestricted ranking-based black-box com-plexity of LeadingOnes∗n) is strictly larger than n − 2.

Towards a Complexity Theory of Randomized Search Heuristics 27

Crucial for the proof is again the combinatorial statement of Lemma 1, fromwhich we concluded that after t queries we know nothing more than t − 1 bitsof the hidden bit string z. We omit the proof details.

The following remark follows easily from the proof of Theorem 14 in [DJK+10].

Remark 1. For every k ≥ 2, the k-ary unbiased ranking-based black-box com-plexity of LeadingOnes∗n is O(n log n).

7 Conclusions

Motivated by the fact that (i) previous complexity models for randomized searchheuristics give unrealistic low complexities and (ii) that many randomized searchheuristics only compare objective values, but not regard their absolute values,we added such a restriction to the two existing block-box models. While thisdoes not change the black-box complexity of the OneMax function class (thisremains relatively low at Θ(n/ log n)), we do gain an advantage for the Bi-naryValue function class. Here the complexity is a ridiculous O(log n) with-out the ranking restriction, but Θ(n) in the ranking-based model. We obtainsome more results improving previous work by different authors, summarized inTable 1. All results indicate that the ranking-based black-box complexity mightbe a promising measure for the hardness of problems for randomized searchheuristics.

Table 1. Black-Box Complexity of OneMax, BinaryValue, and LeadingOnes. Thelower bound for the unbiased ranking-based model also holds for the unrestrictedranking-based model. Abbreviations: unrestr. = unrestricted, ranking-b. = ranking-based.

Model Arity OneMax BinaryValue LeadingOnes

unrestr. n/a Ω(n/ log n) [DJW06] 2 − 2−n [DJW06] Θ(n) [DJW06]O(n/ log n) [AW09]

unbiased 1 Θ(n log n) [LW10] Θ(n log n) [LW10] Θ(n2) [LW10]2 ≤ k ≤ n O(n/ log k) [DJK+10] O(n) [DJK+10] O(n log n) [DJK+10]∗ O(log n) (here) > n − 2 (here)

unbiased 2 ≤ k ≤ n O(n/ log k) (here) Θ(n) (here) O(n log n) (here)ranking-b. ∗ > n − 2 (here)

References

[Ald83] Aldous, D.: Minimization algorithms and random walk on the d-cube.Annals of Probability 11, 403–413 (1983)

[AW09] Anil, G., Paul Wiegand, R.: Black-box search by elimination of fitnessfunctions. In: Proc. of Foundations of Genetic Algorithms (FOGA 2009),pp. 67–78. ACM, New York (2009)

28 B. Doerr and C. Winzen

[DJK+10] Doerr, B., Johannsen, D., Kotzing, T., Lehre, P.K., Wagner, M., Winzen,C.: Faster black-box algorithms through higher arity operators, ArXiv e-prints 1012.0952 (2010); Foundations of Genetic Algorithms XI FOGA(2011, to appear)

[DJTW03] Droste, S., Jansen, T., Tinnefeld, K., Wegener, I.: A new frameworkfor the valuation of algorithms for black-box optimization. In: Proc. ofFoundations of Genetic Algorithms (FOGA 2003), pp. 253–270 (2003)

[DJW06] Droste, S., Jansen, T., Wegener, I.: Upper and lower bounds for random-ized search heuristics in black-box optimization. Theory of ComputingSystems 39, 525–544 (2006)

[DW11] Doerr, B., Winzen, C.: Towards a Complexity Theory of RandomizedSearch Heuristics: Ranking-Based Black-Box Complexity, ArXiv e-prints1102.1140 (2011)

[GJ90] Garey, M.R., Johnson, D.S.: Computers and intractability; a guide to thetheory of np-completeness. W. H. Freeman & Co., New York (1990)

[Han10] Hansen, N.: Private communication (2010)[HGD94] Horn, J., Goldberg, D., Deb, K.: Long path problems. In: Davidor, Y.,

Manner, R., Schwefel, H.-P. (eds.) PPSN 1994. LNCS, vol. 866, pp. 149–158. Springer, Heidelberg (1994)

[HK78] Hausmann, D., Korte, B.: Lower bounds on the worst-case complexity ofsome oracle algorithms. Discrete Math. 24, 261–276 (1978)

[Hro03] Hromkovic, J.: Algorithmics for hard problems: introduction to combi-natorial optimization, randomization, approximation, and heuristics, 2ndedn. Springer, New York (2003)

[LTT89] Llewellyn, D.C., Tovey, C., Trick, M.: Local optimization on graphs. Dis-crete Appl. Math. 23, 157–178 (1989) Erratum: 46, 93–94 (1993)

[LW10] Lehre, P.K., Witt, C.: Black-box search by unbiased variation. In: Proc.of Genetic and Evolutionary Computation Conference (GECCO 2010),pp. 1441–1448. ACM, New York (2010)

[MR95] Motwani, R., Raghavan, P.: Randomized algorithms. Cambridge Univer-sity Press, Cambridge (1995)

[Yao77] Yao, A.C.-C.: Probabilistic computations: Toward a unified measure ofcomplexity. In: Proc. of 18th Annual Symposium on Foundations of Com-puter Science (FOCS 1977), pp. 222–227 (1977)