Black-Box Complexity of the Binary Value Function

TL;DR

This paper refines the understanding of the black-box complexity of the BinVal function, providing tighter bounds and establishing its position among unimodal functions in evolutionary computation.

Contribution

It offers more precise upper and lower bounds for the unbiased black-box complexity of BinVal and proves its status as the easiest unimodal pseudo-Boolean function for unbiased algorithms.

Findings

Upper bound of log_2 n + 2.42141558 - o(1) for BinVal complexity

Lower bound of log_2 n + 1.1186406 - o(1) for BinVal complexity

BinVal is the easiest among unimodal pseudo-Boolean functions for unbiased algorithms

Abstract

The binary value function, or BinVal, has appeared in several studies in theory of evolutionary computation as one of the extreme examples of linear pseudo-Boolean functions. Its unbiased black-box complexity was previously shown to be at most $\lceil \log_2 n \rceil + 2$, where $n$ is the problem size. We augment it with an upper bound of $\log_2 n + 2.42141558 - o(1)$, which is more precise for many values of $n$. We also present a lower bound of $\log_2 n + 1.1186406 - o(1)$. Additionally, we prove that BinVal is an easiest function among all unimodal pseudo-Boolean functions at least for unbiased algorithms.

Equations

$$BB{C}_{\mathcal{X}}(F)=\underset{\mathcal{A}\in \mathcal{X}}{\inf }\underset{f\in F}{\sup }{E}_{\mathcal{A}}(f).$$

$$P_{\mathcal{X}}(y\mid x_1,\dots ,x_k)$$

$$\text{textsc}{BinVal}_{z,\pi }(x)=\sum _{i=1}^n{2}^{i-1}\cdot [z_i=x_{\pi (i)}],$$

$$BB{C}_{\mathcal{X}}(\text{textsc}BinVal)$$

$$\le \underset{\mathcal{A}\in \mathcal{X}}{\inf }\underset{g\in \text{textsc}BinVal}{\sup }{E}_{\mathcal{A}}(x\mapsto f_0(\mathcal{B}(g(x))))=\underset{\mathcal{A}\in \mathcal{X}}{\inf }{E}_{\mathcal{A}}(f_0)$$

$$\stackrel{(\ast )}{=}\underset{\mathcal{A}\in \mathcal{X}}{\inf }\underset{f\in F}{\sup }{E}_{\mathcal{A}}(f)=:BB{C}_{\mathcal{X}}(F),$$

$$\text{textsc}{BinValEx}_{z,\pi }^{(\vec{w})}(x)=\sum _{i=1}^n{w}_i\cdot [z_i=x_{\pi (i)}].$$

$${\log }_{2}n+2.42141558-\Theta ({\log }_{2}n/2^n)$$

$${\log }_{2}n+1.1186406-\Theta ({\log }_{2}n/2^n).$$

$$E(n,d)$$

$$E(n,d,s)$$

$$E(n,d)\le {\log }_{2}n+1+\sum _{z=0}^{\lceil {\log }_{2}n\rceil -1}{\log }_2\left(1+\frac{1}{2^z}\right).$$

$$\varphi (n)=1+\sum _{z=0}^{\lceil {\log }_{2}n\rceil -1}{\log }_2\left(1+\frac{1}{2^z}\right).$$

$$E(n,d,s)$$

$$\le \sum _{t=\max (0,s+d-n)}^{\min (s,d)}({\log }_2\max (s,n-s)+\varphi (\max (s,n-s)))\cdot \frac{\left(\genfrac{}{}{0ex}{}{s}{t}\right)\left(\genfrac{}{}{0ex}{}{n-s}{d-t}\right)}{\left(\genfrac{}{}{0ex}{}{n}{d}\right)}$$

$$={\log }_2\max (s,n-s)+\varphi (\max (s,n-s)).$$

$$E(n,d)\le 1+{\log }_2\frac{n}{2}+\varphi \left(\frac{n}{2}\right)\le {\log }_{2}n+\varphi (n).$$

$$E(n,d)$$

$$={\log }_{2}n+{\log }_2\left(1+\frac{1}{n}\right)+\varphi \left(\frac{n+1}{2}\right).$$

$$2^{k-1}+1\le \frac{n+1}{2}\le 2^k.$$

$${\log }_2\left(1+\frac{1}{n}\right)<{\log }_2\left(1+\frac{1}{2^k}\right)$$

$$E(n,d)$$

$$={\log }_{2}n+{\log }_2\left(1+\frac{1}{2^k}\right)+1+\sum _{z=0}^{k-1}{\log }_2\left(1+\frac{1}{2^z}\right)$$

$$={\log }_{2}n+1+\sum _{z=0}^k{\log }_2\left(1+\frac{1}{2^z}\right)={\log }_{2}n+\varphi (n).\text{qed}$$

$$\sum _{z=0}^{\infty }{\log }_2\left(1+\frac{1}{2^z}\right)=2.2535240379347\dots \le 2.26,$$

$$\sum _{z=k}^{\infty }{\log }_2\left(1+\frac{1}{2^z}\right).$$

$$E(n,d)\ge {\log }_{2}n+\mathrm{0.1186406.}$$

$$E(n,d)\ge {\log }_{2}n+\xi (\lfloor {\log }_{2}n\rfloor ),$$

$$\xi (1)$$

$$E(n,d,s)$$

$$=\sum _{t=t_{\min }+1}^{t_{\max }-1}\max (E(s,s-t),E(n-s,d-t))\cdot P[t]$$

$$+E_{\min }(n,d,s)+E_{\max }(n,d,s),$$

$$\ge ({\log }_2\max (s,n-s)+C)\cdot (1-P[t_{\min }]-P[t_{\max }])$$

$$+E_{\min }(n,d,s)+E_{\max }(n,d,s),$$

$$C$$

$$E_{\min }(n,d,s)$$

Full text

We augment it with an upper bound of $\log_{2}n+2.42141558-o(1)$, which is more precise for many values of $n$. We also present a lower bound of $\log_{2}n+1.1186406-o(1)$. Additionally, we prove that BinVal is an easiest function among all unimodal pseudo-Boolean functions at least for unbiased algorithms.

1 Introduction

Theory of randomized search heuristics studies how various problems are solved by these heuristics, whether it is efficient or not, and what are the key properties of both problems and heuristics that determine the efficiency of the search and the quality of the results. In the current state of this area of computer science there are two major building blocks that augment each other: runtime analysis and black-box complexity theory. The former studies how fast particular randomized search heuristics are on particular problems or problem classes, the latter strives to find how difficult it is to solve a problem (typically from the given class) by the best suitable randomized search heuristic (and why). The gaps between the complexities of various problems and the runtimes of existing algorithms on these problems are an important source of difficult questions and new inspiring results.

The (unrestricted) black-box complexity of a problem, as introduced in [14], is, roughly speaking, the expected runtime of the best possible black-box algorithm solving this problem, measured as the number of queries to the function representing the quality of a solution to the problem. Since every possible black-box algorithm is explicitly permitted, such complexity can be inadequate to explain the performance of randomized search heuristics, as they typically use only a restricted set of possible operations with the candidate solutions. By limiting the possible operations to some well-defined “fair” subset, researchers define more restricted notions of black-box complexity, which hopefully better describe why (particular) randomized search heuristics are good or bad for certain problems.

In particular, the notion of unbiased black-box complexity was introduced in [16] for pseudo-Boolean problems. Since evolutionary algorithms and other randomized search heuristics are designed as general-purpose solvers, they shall not prefer one instance of a problem over another one. This is reflected in the definition of an unbiased black-box algorithm, which, for the particular case of algorithms operating on bit strings, basically amounts to the invariance of the algorithm under transformations preserving the Hamming distance between two candidate solutions, which reduces to invariance under systematic flipping of arbitrary but fixed set of bit indices, and invariance under systematically applying an arbitrary but fixed permutation to all the bits. Unbiased black-box algorithms are regarded as a better model of randomized search heuristics, since these algorithms, just like randomized search heuristics, cannot perform a number of fine-grained operations that can be considered problem-dependent.

Unfortunately, the ways were found to perform most of the work without making queries in the unbiased model too [5, 9]. In fact, it was shown that, with a proper notion of unbiasedness for the given type of individuals, the unbiased black-box complexity coincides with the unrestricted one [18]. Several alternative restricted models of black-box algorithms were subsequently introduced as a reaction, namely ranking-based algorithms [11], limited-memory algorithms [10], and elitist algorithms [13].

One of possible refinements of the unbiased black-box search model is the use of unbiased operators with restricted arity. The original paper [16] studied mostly unary unbiased black-box complexity, e.g. the class of algorithms allowing only unbiased operators taking one individual and producing another one, which can also be seen as mutation-only algorithms. This model appeared to be quite restrictive, e.g. the unary unbiased black-box complexity of OneMax was proven to be $\Theta(n\log n)$ [6, 16]. Together with the rather old question of whether crossover is useful in evolutionary algorithms (which was previously answered positively [8, 15, 19]), this inspired a number of works on higher-arity unbiased algorithms, since many crossovers are binary unbiased operators.

The theorem that for $k\geq 2$ the $k$-ary unbiased black-box complexity of OneMax is $O(n/\log k)$, which was proven in [7], was the first signal that higher arities are useful, which have been followed by a more strong result of $O(n/k)$ for $k=O(\log n)$ [12]. Among others, an elegant crossover-based algorithm with the expected running time of $2n-O(1)$ was presented, which works for all linear functions. Several particular properties of this algorithm inspired the researchers to look deeper for faster general-purpose algorithms that use crossover. The first reported progress of algorithms using crossover on simple problems like OneMax was made in [20], where an algorithm was presented with the same $O(n\log n)$ asymptotic as in simple unary algorithms, but with a better constant factor. An algorithm, called the $(1+(\lambda,\lambda))$ genetic algorithm, was presented in [4] along with the proof of the $O(n\sqrt{\log n})$ runtime on OneMax, which was faster than any evolutionary algorithm before, and improved performance on some other problems. With the use of self-adaptation for its parameter $\lambda$, the $O(n)$ bound was proven for the runtime on OneMax [3], and similar improvements were shown later on a more realistic problem, MAX-SAT [2]. Experiments show that the constant in $O(n)$ is rather small.

Another proof of the usefulness of the crossover has been recently presented in [17]. The paper considers the $(2+1)$ genetic algorithm from [20], which has been previously shown to be faster than the $(1+1)$ evolutionary algorithm, but slower than randomized local search (RLS), on OneMax. However, once the mutation operator is improved in such a way that, when it is the only operator to apply, it always flips at least one bit, this algorithm becomes faster, by a constant factor, than not only RLS, but any other unary unbiased algorithm. This result shows the usefulness of the crossover with a much simpler approach compared to [4].

Unfortunately, there are still no matching lower bounds known for $k$-ary unbiased black-box algorithms with $k>1$, even for OneMax. It seems to be believed that the binary unbiased black-complexity of OneMax is linear, but no lower bounds, other than the trivial $\Omega(n/\log n)$ bound, are known. A part of the difficulty of this problem is that, apart from the best individual like in the unary case [6], one has to track at least one other individual, which need not be second best, to get the best from the ability to perform crossover, which complicates the possible proofs.

Our long-standing conjecture is that the binary unbiased black-box complexity is linear not only for OneMax, but for any linear function, as the binary algorithm from [7] works on linear functions without any changes. The class of linear functions includes the BinVal function, a linear function with weights equal to powers of two. It is notoriously known to have a ridiculously low complexity of $2-\frac{1}{2^{n}}$ when the weights are known to be ordered. A more relevant version that allows arbitrary permutation of weights as well as arbitrary bit strings as optima has been considered in [11], where the upper bound on its black-box complexity was proven to be $\lceil\log_{2}n\rceil+2$. We feel that this is a more suitable function to study lower bounds on the unbiased binary black-box complexity for the following reasons.

• •

Any lower bound can be immediately extended not only to arbitrary linear functions, including OneMax, but to any class of unimodal functions, as any unbiased binary black-box algorithm that can optimize these functions can be applied to BinVal.

• •

The BinVal function reveals, through the fitness values, as much information about the structure of already sampled individuals as it is possible in an unbiased setting, which would simplify the analysis of lower bounds.

Although this paper does not contribute to the field of binary unbiased black-box complexities, we augment the current knowledge about the BinVal function. This paper presents the following contribution.

• •

A constructive procedure to compute the exact black-box complexity of BinVal for any given problem size $n$, which yields an algorithm to solve BinVal with the expected running time equal to this complexity.

• •

An upper bound on the black-box complexity of BinVal, which refines the known $\lceil\log_{2}n\rceil+2$ upper bound for many values of $n$ and is equal to $\log_{2}n+2.42141558-\Theta(\log_{2}n/2^{n})$.

• •

A lower bound on the black-box complexity of BinVal, which is proven for the first time and is equal to $\log_{2}n+1.1186406-\Theta(\log_{2}n/2^{n})$.

The rest of the paper is structured as follows. Section 2 introduces the necessary notation and definitions. Section 3 studies unrestricted and unbiased black-box complexities of BinVal. Finally, Section 4 concludes and gives final remarks.

2 Preliminaries

Throughout the paper, we denote the set of integer numbers $\{1,2,\ldots,n\}$ as $[1..n]$. We denote as $\mathcal{H}(x,y)$ the Hamming distance between two bit strings $x$ and $y$ of the same length, that is, the number of positions at which they do not agree. In a few places we use the notation $\mathcal{B}(x)$ for the integer number $x$ written in the binary numeral system, where the necessary number of leading zeros may need to be prepended depending on the context.

We denote by $E_{\mathcal{A}}(f)$ the expected running time of an algorithm $\mathcal{A}$ on a function $f$, that is, the expected number of queries to that function until its optimum is queried for the first time. The black-box complexity of a class of functions $F$ for a class of algorithms $\mathcal{X}$ is the following value [12]:

[TABLE]

Throughout the paper, we consider only the algorithms operating on bit strings of fixed length. A $k$-ary variation operator [12] $\mathcal{X}$ produces a search point $y$ from the given $k$ search points $x_{1},\ldots,x_{k}$ with probability $P_{\mathcal{X}}(y\mid x_{1},\ldots,x_{k})$. The operator $\mathcal{X}$ is unbiased [16] if the following relations hold for all search points $x_{1},\ldots,x_{k},y,z$ and all permutations $\pi$ over $[1..n]$:

[TABLE]

where $a\oplus b$ is the bitwise exclusive-or operation applied to two bit strings $a$ and $b$ of the same length, and $\pi(a)$ is an application of permutation $\pi$ to a bit string $a$.

The algorithm is a $k$-ary unbiased black-box algorithm [12] if on every iteration it performs the following actions:

• •

Based only on the fitness values of already queried individuals, it chooses:

• –

a non-negative integer number $k^{\prime}\leq k$;

• –

$k^{\prime}$ individuals among the already queried ones, possibly with repetitions, noting that the order of the individuals matters, and

• –

a $k^{\prime}$-ary unbiased variation operator.

• •

It applies the chosen operator to the chosen individuals.

• •

Finally, it evaluates the fitness of an individual which the chosen operator produced.

Another definition for the unbiased black-box algorithm [18] does not explicitly limit the set of possible variation operators, but instead requires that the probability distributions of the produced individuals do not change when the problem undergoes certain transformations (which, in the case of pseudo-Boolean problems, are exactly the class of transformations preserving Hamming distances). However, the definition of a $k$-ary unbiased black-box algorithm becomes identical with the definition from [18] when $k$ is set to infinity, which is allowed by the particular flavour of the definition above. For this reason, any theorem, that holds for $k$-ary unbiased black-box algorithms assuming arbitrary $k$, also holds for “just” unbiased algorithms.

Closely following [11], we consider the following class of functions called “binary value”, or BinVal, defined on bit strings of length $n$:

[TABLE]

where $z\in\{0;1\}^{n}$ is the hidden bit string representing the unknown optimum, $\pi:[1..n]\to[1..n]$ is a hidden permutation of indices from the range $[1..n]$ that defines which weights are given to which indices, and the Iverson bracket $[.]$ is the notation for a function that converts the logic truth to 1 and the logic false to 0. This function has a single global maximum at $x=z$, which we strive to find, with the corresponding function value of $2^{n}-1$.

Unlike the “classical” binary value function, where the weights are rigidly assigned to the bit indices, such definition makes the problem class symmetric with regards to isomorphisms of the Hamming cube that represents the search space. A similar procedure has been done on another famous benchmark function, LeadingOnes, to prove its black-box complexity of $\Theta(n\log\log n)$ [1].

One of the properties that make this function special is that it essentially defines a bijection between the queried bit strings and the function values. This bijection also preserves the Hamming distance: for any $z$ and $\pi$, and for any two bit strings $x_{1}$ and $x_{2}$, it holds that $\mathcal{H}(x_{1},x_{2})=\mathcal{H}(\mathcal{B}(f(x_{1})),\mathcal{B}(f(x_{2})))$, where $f=\textsc{BinVal}_{z,\pi}$. As a result, this function exposes as much of the information about the hidden parameters as possible for an unbiased setting. This property makes BinVal “an easiest function” regarding its unbiased black-box complexity (and, in general, $k$-ary unbiased black-box complexity for any $k$). More formally, the following lemma holds:

Lemma 1**.**

For any integer $k\geq 0$ and $X$ being a class of $k$-ary unbiased black-box algorithms, and for any class of pseudo-Boolean functions $F$ defined on bit strings of length $n$ which (i) consists of functions with a single global optimum and (ii) is symmetric under the Hamming cube isomorphisms, $BBC_{\mathcal{X}}(\textsc{BinVal})\leq BBC_{\mathcal{X}}(F)$.

Proof.

As the problem class $F$ is symmetric under the Hamming cube isomorphisms and consists of functions with a single global optimum, there is a problem instance $f_{0}\in F$ such that the all-ones bit string is a unique optimum.

Now we show that for any algorithm $\mathcal{A}\in\mathcal{X}$ it holds that $E_{\mathcal{A}}(g)\leq E_{\mathcal{A}}(f_{0})$. To do this, we note that the composite problem $h$, defined as $h(x)=f_{0}(\mathcal{B}(g(x)))$, belongs to $F$, because the mapping $x\mapsto\mathcal{B}(f(x))$ is a Hamming-preserving bijection. As $\mathcal{A}$ is unbiased, $E_{\mathcal{A}}(h)=E_{\mathcal{A}}(f_{0})$. On the other hand, an optimum of $h$ is necessarily an optimum of the problem instance $g$, as only such argument to $g$ yields an all-ones bit string, which is an optimum for $f_{0}$. This, in turn, means that $E_{\mathcal{A}}(g)\leq E_{\mathcal{A}}(h)=E_{\mathcal{A}}(f_{0})$.

Now we apply the definitions of black-box complexities and derive that:

[TABLE]

where $:=$ and $=:$ signs denote applying the definition of the black-box complexity, and the move denoted by $(*)$ follows from the fact that $\mathcal{X}$ is a set of unbiased algorithms. ∎

The indefinite article in “an easiest function” reflects the fact that there are infinitely many function classes which are equally easy compared to BinVal. In particular, the following class of functions is of interest at least within this paper:

Lemma 2**.**

The following class of functions, defined on bit strings of length $n$ and parameterized by known real-valued weights $\vec{w}=[w_{1},\ldots,w_{n}]$ such that $w_{i+1}\geq 2\cdot w_{i}$ for all $1\leq i<n$, has the same $k$-ary unbiased black-box complexity, for any $k\geq 0$, as BinVal:

[TABLE]

Proof.

The direction $BBC_{\mathcal{X}}(\textsc{BinValEx})\geq BBC_{\mathcal{X}}(\textsc{BinVal})$, for $\mathcal{X}$ being the class of $k$-ary unbiased black-box algorithms, follows from Lemma 1. Now we prove the reverse direction by reducing a BinValEx problem to a BinVal problem.

It follows from the property of the weights, $w_{i+1}\geq 2\cdot w_{i}$, that $\sum_{j=1}^{i}w_{j}\leq\sum_{j=1}^{i}2^{j-i}\cdot w_{i}\leq(2-2^{1-i})\cdot w_{i}<2\cdot w_{i}$. As a result, the following greedy algorithm can, given a fitness value $f$ on some search point $x$, tell at which $w_{i}$ the bit $x_{\pi(i)}$ matches the bit $z_{i}$:

$i\leftarrow n$. 2. 2.

if $f<w_{i}$, tell the bit for $w_{i}$ does not match, go to step (4). 3. 3.

$f\leftarrow f-w_{i}$, tell the bit for $w_{i}$ matches. 4. 4.

$i\leftarrow i-1$, if $i>0$ go to step (2).

This means that we can easily recreate the value of BinVal for the same $z$ and $\pi$ from the value given by $\textsc{BinValEx}^{(\vec{w})}$ if the weights are known. ∎

In particular, a subproblem of BinVal on arbitrary chosen bit indices, for which the weights are known, is an instance of BinValEx and can be solved in the same way as BinVal of the corresponding size. In the rest of the paper we treat BinVal and the derived BinValEx-type problems uniformly and call them all BinVal.

3 Unrestricted and Unbiased BBC of BinVal

The main result of this paper is as follows:

Theorem 1**.**

The unrestricted, as well as the unbiased black-box complexity of BinVal is at most

[TABLE]

and at least

[TABLE]

Informally, one can imagine an algorithm that works in $O(\log n)$. From the result $\textsc{BinVal}(x_{0})$ of the initial query $x_{0}$, which is essentially a random bit string, we can find the list of weights, at which the bits are guessed correctly, but not yet their positions. By issuing the next query $x_{1}$ where a half of the bits is flipped (randomly, in the case of an unbiased algorithm, or arbitrarily if the algorithm is unrestricted) and analyzing $\textsc{BinVal}(x_{1})$, we get which weights correspond to bits which coincide in $x_{0}$ and $x_{1}$, and which correspond to differing bits, but nothing more. These halves, or subproblems, are essentially two BinValEx functions, which we can treat as plain BinVal functions from now on.

The main idea is that we can optimize them in parallel by combining the queries coming from the subproblems into a single query to the original problem, and on receiving an answer we can easily split it into answers to the queries of the subproblems. On a next step, each of these two problems is again subdivided into halves, and this process continues until the subproblem sizes approach one. A small fraction of the subproblems will find their answers preliminarily by occasionally making all bits equal one or zero. One can also slightly optimize the algorithm by taking an advantage of knowing the number of bits guessed right and deriving an optimal decision on how to split the problem into two subproblems.

We formalize these ideas using the following set of statements.

Definition 1**.**

$E(n,d)$, where $0\leq d\leq n$, is the expected time to optimize a uniformly sampled problem of size $n$, taken from the BinVal class, using an optimal algorithm, given that only the first query is already made and the Hamming distance to the optimum is $d$.

It is clear that $E(n,0)=0$, since the first query has already queried the optimum, and $E(n,n)=1$, as the optimum is the complete inverse of the first query. This also means that for $n=1$ all possible values are already known. The following lemma helps to derive all other values.

Lemma 3**.**

The following holds for $n>1$ and $0<d<n$:

[TABLE]

Proof.

This expression corresponds to making a wise choice for $s$, which is the number of bits to flip randomly, performing the query, which is reflected by “$1+$”, and then by optimally optimizing the appearing subproblems, taking into account that the $d$ bits which are not guessed right can appear randomly in both of the subproblems. As mentioned above, both subproblems are instances of BinValEx, since by comparing the fitnesses of the first and the second queries we can determine which weights correspond to the coinciding bits and to the differing bits. It is easy to see that in both subproblems all the available information can be described as the fitness of the corresponding part of the second query, so we can refer to $E(s,s-t)$ and $E(n-s,d-t)$ as expected times to solve these subproblems.

It is clear that $E(n,d)$ cannot be greater than the right-hand side, as we definitely can do as well as described. Now we show that it cannot be smaller as well.

Assume that there is a smallest $n_{0}>1$ such that for some $d_{0}$ it holds that $E(n_{0},d_{0})$ is smaller than the right-hand side. Consider the next query, and let $s_{\text{opt}}$ be the random variable denoting the amount of bits to flip in the first query to construct the second query. It is clear that $P[s_{\text{opt}}=0]=0$ and $P[s_{\text{opt}}=d]=0$ as well. Under an assumption that $E(n_{0},d_{0})$ is smaller than the right-hand side, there exists an $s_{0}$ such that $0<s_{0}<n_{0}$, $P[s_{\text{opt}}=s_{0}]\neq 0$, and the optimal algorithm is faster than $E(n_{0},d_{0},s_{0})$.

Now consider the value of $t_{s}$, the random variable that describes the number of bits differing from the optimum in the first query among those bits which are different in the first and the second query. It appears that $P[t_{s}=t_{0}]=\frac{\binom{s_{0}}{t_{0}}\binom{n_{0}-s_{0}}{d_{0}-t_{0}}}{\binom{n_{0}}{d_{0}}}$, as whatever way the optimal algorithm selects the $s_{0}$ bits to flip, the distribution of the instances of BinVal that still agree with the two queries is still uniform. As a result, it means that there exists some value $t_{0}$ such that the runtime of the optimal algorithm is smaller than $\max(E(s_{0},s_{0}-t_{0}),E(n_{0}-s_{0},d_{0}-t_{0}))$. It follows that the maximum over these two values is greater than the optimal expected time to solve the corresponding subproblem. As $s_{0}<n_{0}$ and $n_{0}-s_{0}<n_{0}$, this contradicts the assumption that $n_{0}$ is the smallest problem size at which the lemma statement brings suboptimal results. This contradiction proves the lemma. ∎

Now we show that $E(n,d)$ are constrained quite well.

Lemma 4**.**

For all $n>0$ and all $0<d<n$ it holds that:

[TABLE]

Proof.

We prove this statement using induction by $n$. For $n=1$, this statement holds trivially. Now we assume that for all $n^{\prime}<n$ the induction statement holds.

For convenience, we introduce the following shorthand:

[TABLE]

Note that $\phi(n)$ is a non-decreasing function, as well as $\log_{2}n$ and their sum.

The following two inequalities hold for all $n$: $E(n,0)=0\leq\log_{2}n+\phi(n)$ and $E(n,n)=1\leq\log_{2}n+\phi(n)$. We simplify $E(n,d,s)$ from Lemma 3 as follows:

[TABLE]

If $n$ is even, $\min_{s}\max(s,n-s)=\frac{n}{2}$ and the following holds:

[TABLE]

If $n$ is odd, $\min_{s}\max(s,n-s)=\frac{n+1}{2}$, and the derivation is slightly more complicated:

[TABLE]

Now we choose $k$ such that $2^{k}+1\leq n<2^{k+1}$. Note that the last inequality is strict as $n$ is odd. In the following, we use the fact that $2^{k}+2\leq n+1\leq 2^{k+1}$, which results in:

[TABLE]

As a consequence, the sum in $\phi$ runs up to $k-1$. Now we use the following inequality:

[TABLE]

and finish the analysis for the case of $n$ being odd:

[TABLE]

Note that the sum in the statement of Lemma 4 is bounded from above by a constant:

[TABLE]

so a straightforward corollary from Lemma 4 is that $E(n,d)\leq\log_{2}n+3.26$.

In fact, we can refine this additive constant by evaluating all $E(n,d)$ by definition for all $n\leq 2^{k}$, computing the maximum difference $D_{\max}=E(n,d)-\log_{2}n$, and adding the following expression to $D_{\max}$:

[TABLE]

For $k=10$ we found that $D_{\max}<1.4194631$, and the analytical remainder converges to a number slightly smaller than $0.00195248$, which together proves that $E(n,d)\leq\log_{2}n+1.42141558$.

We proceed with the lower bounds.

Lemma 5**.**

For all $n>0$ and $0<d<n$ it holds that:

[TABLE]

Proof.

For $n=1$, this statement holds as the set of possible $d$ is empty. We prove the following by induction for $n\geq 2$:

[TABLE]

where $\xi(t)$ is defined as follows:

[TABLE]

Note that $\xi(t)$ is strictly positive and decreases with $t$, however, the difference $\xi(t)-\xi(t+1)$ decreases sharply as $t$ grows. Another useful property222The proof is moved to Appendix A for clarity. is that $f(n)=\log_{2}n+\xi(\lfloor\log_{2}n\rfloor)$ is a non-decreasing function, from which it follows that $\max(f(n_{1}),f(n_{2}))=f(\max(n_{1},n_{2}))$.

The base of the induction is for $n=2$, where $E(2,1)=1.5=\log_{2}2+\xi(1)$, and for $n=3$, where $E(3,1)=E(3,2)=\frac{7}{3}>2.0849626>\log_{2}3+\xi(1)$. The following needs to be proven for $n\geq 4$, assuming for all smaller $n$ the lemma statement holds. Consider $E(n,d,s)$ from Lemma 3. Let $t_{\min}=\max(0,s+d-n)$, $t_{\max}=\min(s,d)$, then:

[TABLE]

where the following notation is used:

[TABLE]

[TABLE]

The reduction of the middle of the sum is possible as for $t\in(t_{\min};t_{\max})$ the second arguments of both $E(s,s-t)$ and $E(n-s,d-t)$ never turn extreme. For $t=t_{\min}$ and $t=t_{\max}$ the situation is different: for both of them, at least one of the arguments under the maximum becomes extreme (which means either 0 for $E(n,0)$ or 1 for $E(n,n)$). What exactly may happen, depends on how $n$, $s$ and $d$ are related.

Case 1: $s=d$. This renders $t_{\max}=s=d$ and $E_{\max}(n,s,d)=0$ as both values under $\max$ have their seconds arguments zeroed out. The corresponding probability $P[t_{\max}]$ becomes $1/\binom{n}{d}$.

Case 2: $s+d=n$. This renders $t_{\min}=0$ and $E_{\min}(n,s,d)=1$ as both values under $\max$ have their second arguments maximized. The corresponding probability $P[t_{\min}]$ also becomes $1/\binom{n}{d}$.

It appears fruitful to consider two situations: the two cases above may happen together or separately.

Both 1 and 2:

In this case, $s=d$ and $s+d=n$, so $s=d=n/2$ and $n$ is even. Then it holds that (assuming $w=\lfloor\log_{2}n\rfloor$):

[TABLE]

Either 1 or 2: The cases are almost symmetrical, except that Case 1 makes the corresponding subexpression zero and Case 2 makes it one, so we consider Case 1 as a worse one. In this case, the following holds:

[TABLE]

and we are going to show that it is at most $\log_{2}(n/2)+C$. As it cannot happen that $d=n/2$ (otherwise Case 2 happens as well), we are free to consider $1\leq d<n/2$, as $n/2<d<n$ is symmetric.

Now we prove that left hand side of the inequality decreases as $2\leq d<n/2$. We consider the following function for $n\geq 5$:

[TABLE]

After algebraic transformations333The proof is moved to Appendix B for clarity. we find that:

[TABLE]

Note that the difference grows as $d$ grows, so it is enough to prove that it is non-negative when $d=2$. After such substitution, replacing $\log_{2}$ with $\ln$ and multiplying $C$ by $\ln 2$, and using that $\ln(1+x)\geq x-x^{2}/2$, we get that the difference is at most:

[TABLE]

By multiplying by $(n-3)$, which retains the sign, opening all brackets and retaining only negative addends apart from $+1$, we get the following:

[TABLE]

By replacing the last fraction by 1, applying $\frac{\ln(n-3)}{n}\leq 0.202$ for $n\geq 5$ and replacing all $n$ with 5, we get:

[TABLE]

which is positive for all $C\leq 0.88$. For this reason, the lower bound can be reached on either $\psi(n,1,C)$ or $\psi(n,\lfloor\frac{n-1}{2}\rfloor,C)$.

First, we show that:

[TABLE]

This is non-negative for $n\geq 4$, using that $\log_{2}(n-1)/n\leq 0.402$ and the rest of the function is monotone in $n$, for all $C\leq 0.728$.

Next, we prove similar relations for $\psi(n,\lfloor\frac{n-1}{2}\rfloor,C)$, which are written uniformly using $\Delta=2$ for even $n$ and $\Delta=1$ for odd $n$:

[TABLE]

For this we again use $\ln(1+x)\geq x-x^{2}/2$ and prove444The proof is moved to Appendix C for clarity. that the last subtrahend, divided by $n$, grows with $n$. The proofs work for $C\leq 0.57908006$.

As a result, when either Case 1 or Case 2 happens, but not both, we proved that $E(n,d,s)\geq\log_{2}\frac{n}{2}+C=\log_{2}n+C-1$.

Case 3: all other cases. In these cases, only one of the values under $\max$ becomes either 0 or 1, while another value obeys the general rule and is at least one. There are two pairs of symmetrical cases, and without loss of generality we consider only one of them: $t_{\min}=0,n>s+d$. This case influences $E_{\min}$, which becomes:

[TABLE]

If $n-s\geq s$, $E_{\min}$ is not actually altered and follows the general scheme, so we further assume that $s>n-s$. Under this assumption, no other symmetric cases from this point can simultaneously influence $E(n,d,s)$, so we write:

[TABLE]

As a summary, in all cases except when Case 1 and Case 2 happen simultaneously, $E(n,d,s)\geq\log_{2}n+C-1\geq\log_{2}n+\xi(\lfloor\log_{2}n\rfloor)-1$, and in the remaining case $E(n,d,s)\geq\log_{2}n+\xi(\lfloor\log_{2}n\rfloor)-1$ was proven directly, which completes the induction.

To complete the proof of the entire lemma, it is enough to note that $\xi(n)$ converges to its limit with the superpolynomial speed. For instance, $\xi(5)\approx 0.11864060660016391$ and $\xi(6)=\xi(5)$ within the double floating point precision. As a result, one can safely use the lower bound $\xi(n)\geq 0.1186406$. ∎

In practice, due to various pessimizations in our proofs, the lower bound is a little bit better: $E(n,d)\geq\log_{2}+\frac{1}{6}$ for all $n$ and $0<d<n$. Now we are ready to prove the main result of this paper.

Proof of Theorem 1.

Lemmas 4 and 5, along with the refinement of the former based on the exact computations of $E(n,d)$, impose the following restrictions on $E(n,d)$ for $0<d<n$:

[TABLE]

The black-box complexity is:

[TABLE]

which we bound from above as follows:

[TABLE]

and from below by $\log_{2}n+1.1186406-\Theta(\log n/2^{n})$ in the same way. ∎

4 Conclusion

We proved quite sharp bounds on the black-box complexity of permutation-enabled version of the binary value (BinVal) function, which is $\log_{2}n+\Theta(1)$, where the constants that define $\Theta(1)$ are also known and their difference is less than $1.4$. The upper bound complements the existing upper bound from [11], as it is more precise for roughly a half of problem sizes (see Fig. 1 for visual comparison), and the lower bound was proven for the first time.

We feel that BinVal, due to its all-revealing fitness, may be used as a convenient tool to prove the lower bounds on $k$-ary unbiased black-box complexities of unimodal functions, including OneMax, for which it is still an open question for many years.

Appendix A Properties of $\xi$

The function $\xi(k)$ is defined as follows:

[TABLE]

First we show that $\xi(k+1)\geq\xi(k)/3$. This will automatically show that $\xi(k)>0$ and that it decreases as $k$ grows. From this fact, it also holds that there exists a constant $C_{0}\geq 0$ such that $\xi(k)\geq C_{0}$.

To do this, we use induction to assume $\xi(k)\geq\frac{1}{2}\cdot\frac{1}{3^{k-1}}$ and show that:

[TABLE]

To get out the last occurences of $k$ that may influence the sign of the expression, we show that the last fraction is non-increasing:

[TABLE]

So we can finish proving this statement by substituting $k=1$ into the last fraction:

[TABLE]

Second we show that $f(n)=\log_{2}n+\xi(\lfloor\log_{2}n\rfloor)$ is non-decreasing for integer $n\geq 2$. It is enough to show it for pairs $n_{1}=2^{k}-1$ and $n_{2}=2^{k}$, $k\geq 2$, since on other occasions the $\xi$-related part does not change, and $\log_{2}n$ is a non-decreasing function. First we transform the required inequality into a simpler form:

[TABLE]

Now we show that $\frac{k}{2^{k}\cdot\frac{(2^{k}-2)!}{2^{k-1}!2^{k-1}!}}$ is a decreasing function for $k\geq 2$. Indeed:

[TABLE]

Now in (2) there is a decreasing function on the left hand side and an increasing one on the right hand side. When $k=2$, this is:

[TABLE]

which completes the proof.

Appendix B Tedious Transformation #1

We consider the following function for $1\leq d<n/2$:

[TABLE]

The following holds:

[TABLE]

Appendix C Tedious Transformation #2

Using the same definition as above, we prove that $\psi(n,\lfloor\frac{n-1}{2}\rfloor,c)\geq\log_{2}\frac{n}{2}+c$ for small enough $c$, and for $n\geq 4$. To denote $\lfloor\frac{n-1}{2}\rfloor$ more conveniently, we use a macro $\Delta=2$ for even $n$ and $\Delta=1$ for odd $n$, such that this value becomes $\frac{n-\Delta}{2}$. We use the lower bound for $\ln(1+x)\geq x-x^{2}/2$.

[TABLE]

First we want to show that the last expression from above grows with $n$ (increasing by 2) starting from $n=3$ for $\Delta=1$ and from $n=4$ for $\Delta=2$. For this, it is enough to show that the following function grows with $n$, while $n$ increases each time by 2, starting from $2+\Delta$:

[TABLE]

To do that, we estimate $\eta(n+2,\Delta)/\eta(n,\Delta)$ and prove that it is at most one:

[TABLE]

where in the move labeled ($*$) we considered what happens when $\Delta=1$ and $\Delta=2$ and “optimized” the appearance of the result, and the last move used the fact that $x^{2}>x+1$ for $x\geq 2$.

Next, we estimate $\eta(n,\Delta)$ from above by taking it at $n=6-\Delta$ (which is $n=4$ for $\Delta=2$ and $n=5$ for $\Delta=1$):

[TABLE]

Now the statement that we need to prove is essentially equivalent to proving the following:

[TABLE]

For $\Delta=1$ this holds for $c\leq\frac{9-5\ln 3}{9\ln 2}\approx 1.011888$, for $\Delta=2$ it holds for $c\leq\frac{1.5-\ln 3}{\ln 2}\approx 0.57908006$.