vi local mutation scheme for the rate leads to an expected optimization time of the best possible O(nλ/ log λ + n log n). Our result shows that self-adaptation in evolutionary computation can find complex optimal parameter settings on the fly. At the same time, it proves that a relatively complicated self-adjusting scheme can be replaced by the simple endogenous scheme.

iii

Résumé

De nombreux problèmes d'optimisation du monde réel sont trop complexes pour être résolus en temps polynomial. Un moyen de traiter de tels problèmes utilise « randomized search heuristics » (RSHs), qui produisent des solutions plus efficacement en compromettant l'optimalité, l'exhaustivité, l'exactitude ou la précision. Les RSHs initialisent d'abord un point de recherche avec une position aléatoire dans l'espace de recherche, puis résolvent les problèmes de manière itérative jusqu'à ce qu'un critère de terminaison soit rempli. À chaque itération, ils répètent les étapes suivantes : générer un ou plusieurs candidats ; évaluer la qualité des nouveaux individus ; mettre à jour les informations connues. Puisque les RSHs ne nécessitent aucune information que les valeurs objectives des points de recherche évalués, nous les appelons algorithmes d'optimisation de boîte noire.

Les RSHs sont des algorithmes paramétrés et leurs performances typiquement dépendent de manière cruciale de la valeur de ces paramètres. Un nombre de résultats montrent qu'il peut être avantageux de choisir les paramètres de manière dynamique, afin de permettre aux algorithmes de s'adapter au problème à résoudre et à l'état actuel du processus d'optimisation. Une évaluation rigoureuse des gains de performance pouvant être obtenus en modifiant les paramètres lors de l'exécution fait toutefois largement défaut.

Dans ce travail, nous contribuons à notre connaissance de la manière de contrôler les paramètres en ligne de diverses façons. Nous étudions la fonction OneMax qui est définie via {0, 1} n → R, x → n i=1 x i . Dans un premier temps, nous démontrons une borne inférieure pour l'efficacité de tout algorithme unaire non-biaisée de type boîte noire. Plus précisément, nous prouvons que tout algorithme de ce type nécessite n ln(n)cn ± o(n) itérations, en moyenne, pour trouver la solution optimale à ce problème, où c est une constante entre 0, 2539 et 0, 2665. Ce temps d'exécution peut être obtenu avec un (1+1)-type algorithme simple en utilisant un paramètre fitnessdépendant. Le meilleur algorithme non-biaisé statique a besoin de n ln(n) -0.1159n itérations (borne optimale de RLS). Pour tout budget fixe d'évaluations de fonctions, notre algorithme génère des solutions 13% meilleures que celles proposées par le meilleur algorithme unaire non-biaisé à paramètres statiques.

Sur la base des paramètres dynamiques optimaux analysés pour OneMax, nous montrons que le paramètre fitness-dépendant peut être remplacé par un paramètre d'auto-ajustement sans perte d'efficacité. Le mécanisme d'ajustement consiste à apprendre de manière adaptative la stratégie actuellement optimale des itérations précédentes. Il utilise donc des évaluations antérieures pour estimer les progrès espérés qui peuvent être atteint par les différentes valeurs des paramètres, et choisit avidement celui qui maximise cette estimation. Seulement avec une faible probabilité o(1), une valeur de paramètre uniformément aléatoire est choisie.

Nous étendons ensuite notre stratégie d'auto-ajustement aux algorithmes d'évolution (EAs) basés sur la population, qui utilisent des mécanismes inspirés par l'évolution biologique, tels que la reproduction, la mutation, la recombinaison et la sélection. Grosso modo, l'idée principale des EAs est de créer par itération λ points de recherche en utilisant deux valeurs de paramètre différentes. Chacun génère la moitié de la population. Le paramètre est ensuite mis à jour en fonction de celui utilisé dans la sous-population qui contient le meilleur point de recherche. Nous analysons comment cette (1 + λ) EA d'auto-ajustement optimise la fonction de test pour OneMax. Nous prouvons qu'il trouve l'optimum dans un nombre espéré de O(nλ/ log λ + n log n) itérations. Ce temps est asymptotiquement inférieur au temps d'optimisation du classique (1 + λ) EA avec des paramètres statiques. Des travaux antérieurs montrent que la performance de notre algorithme est la meilleure possible parmi tous les λ-parallèle algorithmes non-biaisés mutation-basés.

Nous proposons et analysons également une version auto-adaptative de (1, λ) EA dans laquelle le taux de mutation actuel fait partie de l'individu et est donc également soumis à la mutation. Une analyse rigoureuse du temps d'exécution de la fonction de benchmark OneMax révèle qu'un schéma de mutation locale simple pour le taux conduit à un temps d'optimisation espéré du meilleur possible O(nλ/ log λ + n log n). Notre résultat montre que l'auto-adaptation dans le calcul évolutif peut trouver des paramètres optimaux complexes à la volée. Dans le même temps, il prouve qu'un schéma d'auto-ajustement relativement compliqué peut être remplacé par le schéma endogène simple.

Abstract

Many real-world optimization problems are too complex to be solved in polynomial time. One way to deal with such problems is using randomized search heuristics (RSHs), which produce solutions more efficiently by compromising on optimality, completeness, accuracy, or precision. RSHs first initialize a search point with a random position in the search-space and then solve problems iteratively until a termination criterion is met. In each iteration, they repeat the following steps: generate one or more candidates; evaluate the quality of the new individuals; update the known information. Since RSHs do not require any other information than the objective values of the evaluated search points, we call them black-box optimization algorithms.

RSHs are parametrized algorithms, and their performance typically depends very crucially on the value of these parameters. A number of results show that it can be advantageous to chose the parameters dynamically, to allow the algorithms to adjust to the problem at hand and to the current state of the optimization process. A rigorous evaluation of the performance gains that can be obtained by changing the parameters during the execution is, however, largely missing.

In this work, we contribute to our knowledge of how to control the parameters online in various ways. We study the OneMax function which is defined via {0, 1} n → R, x → n i=1 x i . In a first step, we prove a lower bound for the efficiency of any unary unbiased black-box algorithm. More precisely, we prove that any such algorithm needs n ln(n)cn ± o(n) iterations, on average, to find an optimal solution for this problem, where c is a constant between 0.2539 and 0.2665. This runtime can be achieved with a simple (1+1)-type algorithm using a fitness-dependent parameter setting. The best static unary unbiased algorithm needs n ln(n) -0.1159n iterations (sharp RLS bound). For any fixed budet of function evaluations, our algorithm generates solutions that are better by 13% than those offered by the best unary unbiased algorithm with static parameters.

Based on the analyzed optimal dynamic parameters for OneMax, we show that the fitness-dependent setting can be replaced by a self-adjusting one without losing efficiency. The adjusting mechanism is to adaptively learn the currently optimal strategy from previous iterations. It thus uses past evaluations to estimate the expected progress that can be achieved by the different parameter values, and greedily chooses the one that maximizes this estimation. Only with a small o(1) probably a uniformly random parameter value is chosen.

We then extend our self-adjusting strategy to population-based evolutionary algorithms (EAs) which use mechanisms inspired by biological evolution, such as reproduction, mutation, recombination, and selection. Roughly speaking, the main idea of the EAs is to create per iteration λ search points using two different parameter values. Each one generates half of the population. The parameter is then updated based on the one used in that subpopulation which contains the best search point. We analyze how this self-adjusting (1 + λ) EA optimizes the OneMax test function. We prove that it finds the optimum in an expected number of O(nλ/ log λ + n log n) iterations. This time is asymptotically smaller than the optimization time of the classic (1 + λ) EA with static parameters. Previous work shows that the performance of our algorithm is best-possible among all λ-parallel mutation-based unbiased black-box algorithms.

We also propose and analyze a self-adaptive version of the (1, λ) EA in which the current mutation rate is part of the individual and thus also subject to mutation. A rigorous runtime analysis on the OneMax benchmark function reveals that a simple Chapter 1

Introduction

Many real-world optimization problems are too complex to be solved in polynomial time. One way to deal with such problems is using heuristic algorithms which produce solutions more efficiently by compromising on optimality, completeness, accuracy, or precision. The objective of a heuristic is to produce a "good enough" solution in a reasonable runtime. This solution may not be an optimal one, but it is still valuable because finding it does not require a prohibitively long time.

An important class of heuristic algorithms are randomized search heuristics (RSHs) which try to optimize a problem in an iterative trial and error fashion. Since these algorithms use only the function values of the evaluated solutions, and do not require any additional information (in particular, no gradients, etc.), RSH are also referred to as black-box methods. RSH first initialize a search point with a random position in the search-space and then solve problems iteratively until a termination criterion is met (e.g. number of iterations performed, or adequate objective value (referred to as fitness) reached). In each iteration, RSHs repeat the following steps: generate one or more solution candidates; evaluate the quality of the new individuals; update the known information.

Among the most prominent RSHs are local search variants, simulated annealing, evolutionary and genetic algorithms, and swarm intelligence algorithms. In this work, we focus on randomized local search (RLS) and evolutionary algorithms (EAs). Local search takes a potential solution to a problem and checks its immediate neighbors (that is, solutions that are similar except for very few minor details) in the hope of finding an improved solution. Evolutionary algorithms use mechanisms inspired by biological evolution, such as reproduction, mutation, recombination, and selection. Search points (offspring) play the role of individuals in a population, and evolution takes place at the end of each iteration based on offsprings' quality.

RSHs are parametrized algorithms, and their performance typically depends very crucially on the value of these parameters. An important goal of research on RSHs is to determine optimal parameter choices in these algorithms-a challenging task due to the complex inter-dependencies between different parameters and the random choices of the algorithms. Theory of randomized search heuristics, and in particular the sub-discipline of runtime analysis, aims to contribute to the parameter selection question by providing mathematically founded statements that lay open the influence of the parameter values on the performance.

The majority of these works investigate static parameter settings, i. e., the parameters are fixed before the start of the algorithm and are not changed during its execution. More recently, a number of results were shown which prove an advantage of dynamic parameter settings, that is, the parameters of the algorithm are changed during its execution. Many of these rely on making the parameters functionally dependent on the current state of the search process, e.g., on the fitness of the current-best individual. While this provably can lead to better performances, it leaves the algorithm designer with an even greater parameter setting task, namely inventing a suitable functional dependence instead of fixing numerical values for the parameters.

Finding appropriate fitness-dependent parameter values is non-feasible already for quite simple optimization problems, and seems out of range for real-life optimization tasks. Luckily, it turns out that this step is not necessarily needed, as good parameter values can sometimes be found by automated parameter selection mechanisms, which take into account the recent performance. A number of results show that such on the fly or self-adjusting parameter settings can give an equally good performance as the optimal fitness-dependent parameter setting, however, with much less input from the algorithm designer. Inspiration comes from the continuous optimization, e.g., the 1/5-th rule independently discovered in [Rec73;[START_REF] Devroye | The compound random search[END_REF][START_REF] Schumer | Adaptive step size random search[END_REF]. In a nutshell, this rule suggests to increase the search radius when more than 1/5-th of all offspring are better than the current-best solution, and to decrease the search radius otherwise. The 1/5-th rule originates from theoretical studies of the optimization of the sphere function

x 2 i with a so-called (1 + 1) Evolution Strategy. This rule has inspired success-based parameter control mechanisms, which update the parameter values depending on whether or not an iteration has been successful in finding a better than the previous-best solution. This rule has found applications in continuous and in discrete optimization.

In this work, we focus on parameter control for discrete search spaces, especially for the OneMax problem, which is one of most frequently analyzed problems in the theory of evolutionary algorithms (cf. Section 1.1 for a definition). To deeply understand the influence of the parameters, we first compute a preise lower bound for the efficiency of any so-called unary unbiased black-box algorithm on this problem. Such unary unbiased algorithms are of (1 + 1) type (that is, they produce and evaluate in each iteration only one new solution candidate by modifying at most one of the previously evaluated ones) and treat both the bit-positions and the bit-values in a symmetric fashion. We prove that any such algorithm needs n ln(n)cn ± o(n) iterations, on average, to find an optimal solution for this problem, where c is a constant between 0.2539 and 0.2665. This runtime can be achieved with a simple fitness-dependent parameter setting. In contrast, the best static unary unbiased algorithm, Randomized Local Search, needs n ln(n) -0.1159n iterations [START_REF] Doerr | The Impact of Random Initialization on the Runtime of Randomized Search Heuristics[END_REF] to optimize OneMax. This smallish looking improvement of roughly 0.14n in the Θ(n log n) runtime translates into a 13% better fixed-budget performance, in the sense that after a fixed number (budget) of iterations the expected distance of the solution found by our algorithm with dynamic parameter choices to the optimal solution is roughly 13% smaller than the distance produced by RLS, provided that the budget allows for at least 0.2675n iterations. After we know what the suitable fitness-dependent mutation strengths look like, we design for three different algorithms strategies to control the parameters and prove, by mathematical means, that they achieve close-to-optimal performance on the OneMax problem.

OneMax The OneMax problem is a classic bit-counting problem. It maps each bit string to the number of ones it contains, i.e., each bitstring x ∈ {0, 1} n of length n is mapped to This function thus consist of a huge plateau of constant fitness and only one optimal point.

We notice that all three functions have unique optima. Such functions without local optima are called unimodal. The OneMax function is smooth and can be easily solved using hill climbing algorithms; the LeadingOnes function is one the simplest non-separable functions in discrete optimization, which means that the influence of individual bit values on the overall function value can depend on the other bit values; the Needle function is a typical plateau function where algorithms can basically just do a random walk. These problems are popular in the theoretical works on the analysis of the EAs.

Among these functions, and, more generally, among all benchmark functions analyzed in the theory of randomized search heuristics, the OneMax function is the most popular one since it allows to analyze how the heuristics perform on smooth parts of an optimization problem, where better function values guide the search towards the optimum. It is widely believed that heuristics which solve (much more complex) realworld problems should have no problem to optimize the OneMax problem. In the theory of randomized search heuristics, a good performance on OneMax is therefore often considered to be a minimum requirement that an algorithm needs to pass before it is investigated further. In this work, we focus on the theoretical analysis on the OneMax problem. We also do experimental runs on the LeadingOnes problem in Chapter 3. Both LeadingOnes function and Needle function will be used in the description of related works.

Summary of Contributions

Drift Maximizer Achieves the Precise Unary Unbiased Black-Box Complexity (Apart From an o(n) Additive Term)

The inherent difficulty of proving runtime guarantees for evolutionary algorithms and other RSHs for a long time prohibited runtime results that are more precise than giving the asymptotic order of magnitude. It is known that the unary unbiased blackbox complexity of OneMax is of order n log n [START_REF] Per | Black-Box Search by Unbiased Variation[END_REF]. We note here that black-box complexity is the minimum expected runtime that a black-box optimization algorithm needs to solve a problem; the unary unbiased back-box model in addition requires that all search points are sampled from unary distributions which are symmetric with respect to bit values and bit positions, cf. Section 2.1 for a detailed description. The simple randomized local search heuristic (RLS), which in each iteration applies a random single bit flip on a best-so-far search point, is easily seen to have a runtime of (1 + o(1))n ln(n) by a reduction to the coupon collector problem. Its precise optimization time is n ln(n) + (γln(2)) + o(1) ≈ n ln n -0.1159n, where γ = 0.5772 . . . is the Euler-Mascheroni constant [START_REF] Doerr | The Impact of Random Initialization on the Runtime of Randomized Search Heuristics[END_REF]. The previously best known unary unbiased algorithm has an expected runtime that is smaller than that of RLS by an additive

Θ(

√ n log n) term [START_REF] De Perthuis De Laillevault | Money for Nothing: Speeding Up Evolutionary Algorithms Through Better Initialization[END_REF]. In Chapter 3, we bring precise runtime analysis and black-box complexity together. By determining the black-box complexity more precisely than up to the asymptotic order, we shall understand more precisely the problem difficulty, but also learn improved ways to solve the problem. Taking the unary unbiased black-box complexity as first object of investigation, we derive a simple (1+1)-type algorithm that, by using a fitness-dependent mutation strength, has a time complexity larger than the theoretical optimum by only an additive εn term (ε a small constant). We show a precise bound for the unary unbiased black-box complexity of OneMax. More precisely, we show that it is n ln(n)cn ± o(n) for a constant c for which we show 0.2539 < c < 0.2665. We also show how to numerically compute this constant with arbitrary precision. Equally important, our analysis reveals (and needs) a number of interesting structural results. In particular, in the language of fixed-budget computation as introduced by Jansen and Zarges [START_REF] Jansen | Performance analysis of randomised search heuristics operating with a fixed budget[END_REF], the drift-maximizing algorithm with a budget of at least 0.2675n iterations computes a solution with expected fitness distance to the optimum roughly 13% smaller than the output of the previously best known algorithm. The result have been published at GECCO'16 [START_REF] Doerr | Optimal parameter choices via precise black-box analysis[END_REF].

Self-adjusting RLS also Achieves the Same Complexity

Based on the analysis of the near-optimal mutation strength, we have proposed at PPSN'16 [START_REF] Doerr | k-Bit mutation with selfadjusting k outperforms standard bit mutation[END_REF] a variant of RLS with self-adjusting mutation strengths which can both avoid the performance loss of standard bit mutation and avoid the risk of getting stuck in local optima. The idea is to let the algorithm learn the optimal mutation rate autonomously by analyzing the past performance of the different mutation strengths. Such an on-the-fly learning are subject to an exploration-exploitation trade-off in that they want to exploit those parameter values that are assumed to be optimal at different stages of the optimization process, but also need to allocate some positive probability to select sub-optimal parameter values, in order to be able to detect if some of these have become superior in the meantime. Our algorithm therefore chooses in each iteration with some small probability δ a random parameter and greedily selects the parameter value from which it expects the best progress in fitness otherwise, i.e., with probability 1δ.

We experimentally analyze our new algorithm on the LeadingOnes and the minimal spinning tree (MST) problem. We observe that, for suitable parameter settings, it clearly outperforms the (1+1) EA. Interestingly, it even beats the randomized local search (RLS) heuristic (flipping always one bit) for the LeadingOnes problem and the variant of RLS flipping one or two bits for the MST problem. This shows that for these problems a better performance can be obtained from a mutation strength that changes over time, and that our algorithm is able to find such superior fitnessdependent mutation strengths on the fly. We also make this effect mathematically precise for OneMax. We show that our algorithm essentially is able to find the close-to-optimal mutation schedule identified in our above-described work [START_REF] Doerr | Optimal parameter choices via precise black-box analysis[END_REF]. More precisely, with high probability our algorithm always (apart from a lower-order fraction of the iterations) uses a mutation strength which gives an expected progress equal to the best possible progress (again, apart from lower order terms). Consequently, it has the same optimization time (apart from an o(n) additive lower order term) and the same asymptotic 13% superiority in the fixed-budget perspective as the drift maximizer proposed in [START_REF] Doerr | Optimal parameter choices via precise black-box analysis[END_REF].

Self-adjusting (1+λ) EA Achieves the λ-parallel Mutation-Based Unbiased Black-box Complexity

Inspired by the self-adjusting algorithm proposed in [START_REF] Doerr | k-Bit mutation with selfadjusting k outperforms standard bit mutation[END_REF], we notice that some of the difficulties of the learning mechanism, e.g., the whole book-keeping being part of it and also the setting of the parameters regulating how to discount information over time, can be overcome by using a (1+λ) EA, which samples λ independent offspring per iteration. In a sense, the use of larger populations enables us to adjust the mutation rate solely on information learned in the current iteration. However, we do also use the idea of [START_REF] Doerr | k-Bit mutation with selfadjusting k outperforms standard bit mutation[END_REF] to intentionally use parameter settings which appear to be slightly off the current optimum to gain additional insight and to be able to detect and to react to a change in the optimal parameter values.

In Chapter 4, we propose a new way to self-adjust the mutation rate in populationbased evolutionary algorithms in discrete search spaces. It aims at overcoming some of the difficulties of the learning mechanism just described. It consists of creating half the offspring with a mutation rate that is twice the current mutation rate and the other half with half the current rate. The mutation rate is then updated according to which subpopulation contains the best offspring. Instead of always modifying the mutation rate to the rate of the best offspring, we shall take this winner's rate only with probability a half and else modify the mutation rate to a random one of the two possible values (twice and half the current rate). Our motivation for this modification is that we feel that the additional random noise will not prevent the algorithm from adjusting the mutation rate into a direction that is more profitable. However, the increased amount of randomness may allow the algorithm to leave a possible basin of attraction of a locally optimal mutation rate.

We analyze how the (1 + λ) evolutionary algorithm with this self-adjusting mutation rate optimizes the OneMax test function. We prove that this dynamic version of the (1 + λ) EA finds the optimum in an expected optimization time (number of fitness evaluations) of O(nλ/ log λ + n log n). This time is asymptotically smaller than the optimization time of the classic (1 + λ) EA. Previous work in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] shows that this performance is best-possible among all λ-parallel mutation-based unbiased black-box algorithms.

As an interesting side remark, our proofs reveal that a quite non-standard but fixed mutation rate of r = ln(λ)/2 also achieves the Θ(log log λ) improvement as it implies the bound of Θ(n/ log λ) generations if λ is not too small. Hence, the constant choice r = O(1) as studied in [START_REF] Gießen | The interplay of population size and mutation probability in the (1+λ) EA on OneMax[END_REF] does not yield the asymptotically optimal number of generations unless λ is so small that the n log n-term dominates. These results have been presented at GECCO'17 [START_REF] Doerr | The (1+λ) Evolutionary Algorithm with Self-Adjusting Mutation Rate[END_REF]. 1

Extend the Self-adjusting Strategy to Non-elitist Algorithm Self-adaptive (1,λ) EA

In Chapter 5, we propose and analyze a self-adaptive version of the (1, λ) evolutionary algorithm in which the current mutation rate is part of the individual and thus also subject to mutation. A rigorous runtime analysis on the OneMax benchmark function reveals that a simple local mutation scheme for the rate leads to an expected optimization time (number of fitness evaluations of O(nλ/ log λ + n log n). This time is asymptotically smaller than the optimization time of the classic (1, λ) EA and as mentioned above (1 + λ) EA for all static mutation rates and best possible among all λ-parallel mutation-based unbiased black-box algorithms.

Our result shows that self-adaptation in evolutionary computation can find complex optimal parameter settings on the fly. At the same time, it proves that a relatively complicated self-adjusting scheme for the mutation rate proposed in Chapter 4 can be replaced by our simple endogenous scheme. These results will be presented at GECCO'18 [START_REF] Doerr | Runtime Analysis for Self-adaptive Mutation Rates[END_REF]. 2 .

Related Work

Since the parameter setting has a decisive influence on the performance of RSHs, it is not surprising that it is one of the most intensively studied research questions in the domain of heuristic optimization. Most works, however, study the influence of the parameters on performance by empirical means, whereas here in this work we are rather concerned with rigorous mathematical runtime results. We summarize in this section some of the few known results that are precise enough to determine optimal parameter settings. Not surprisingly, the OneMax benchmark problem also considered in this thesis plays a central role in the works.

Static Parameter Choices

A very early work on precise runtime analysis, apparently overlooked by many subsequent works, is the very detailed analysis on how the (1+1) EA with general mutation rate c/n, c a constant, optimizes the Needle and OneMax functions [START_REF] Garnier | Rigorous Hitting Times for Binary Mutations[END_REF]. Disregarding here the results on the runtime distributions, this work shows that the (1+1) EA with mutation rate c/n finds the optimum of the Needle function in

(1 + o(1)) 1 1-e -c 2 n time. For OneMax, the runtime estimate in [GKS99] is (1 + o(1)) e c c n ln(n), more pre- cisely, e c c n ln(n) ± O(n).
The proof of the latter result uses several deep tools from probability theory, among them Laplace transforms and renewal theory. For a simple proof of the upper bound (1 + o(1))en ln(n) for mutation rate 1/n, see, e.g., [START_REF] Droste | On the analysis of the (1+1) Evolutionary Algorithm[END_REF]. The first proofs of a lower bound of order (1o(1))en ln(n) using more elementary methods where given, independently, in [START_REF] Doerr | Quasirandom evolutionary algorithms[END_REF][START_REF] Sudholt | A New Method for Lower Bounds on the Running Time of Evolutionary Algorithms[END_REF]. An improvement to en ln(n) -O(n) was presented in [START_REF] Doerr | Sharp bounds by probability-generating functions and variable drift[END_REF]. Very recently, again for the case c = 1, a very precise analysis of the expected runtime, specifying all lower order terms larger than Θ(log(n)/n) with precise leading constant, was given in [START_REF] Hwang | Probabilistic analysis of the (1+1)-evolutionary algorithm[END_REF].

That the runtime bound of (1 + o( 1)) e c c n ln(n) holds not only for OneMax, but any linear pseudo-Boolean function, was shown in [START_REF] Witt | Tight Bounds on the Optimization Time of a Randomized Search Heuristic on Linear Functions[END_REF]. Since the mutation rate determines the leading constant of the runtime, a rate of 1/n gives the asymptotically best runtime. Using single bit flips is also a suitable choice for the classic randomized local search with static mutation strengths. By a reduction to the coupon collector problem, we obtain a runtime of (1 + o(1))n ln(n) which matches the current known unary unbiased black-box complexity of order n log n.

An extension of the OneMax result to (1 + λ) EAs was obtained in [START_REF] Gießen | Population Size vs. Mutation Strength for the (1+λ) EA on OneMax[END_REF]. The bound of (1 + o( 1))( e c c n ln(n) + nλ ln ln(λ)/2 ln(λ)) fitness evaluations contains the surprising result that the mutation rate is important for small offspring population sizes, but has only a lower-order influence once λ is sufficiently large (at least when restricted to mutation rates in the range Θ(1/n); note that Lemma 4.2 indicates that mutation rates of a larger order of magnitude can give asymptotically smaller runtimes for larger values of λ).

In parallel independent work, the precise expected runtime of the (1+1) EA on the LeadingOnes benchmark function was determined in [BDN10; Sud13] (note that [START_REF] Sudholt | A New Method for Lower Bounds on the Running Time of Evolutionary Algorithms[END_REF] is the journal version of a work that appeared at the same conference as [START_REF] Böttcher | Optimal fixed and adaptive mutation rates for the LeadingOnes problem[END_REF]). The work [START_REF] Sudholt | A New Method for Lower Bounds on the Running Time of Evolutionary Algorithms[END_REF] is more general in that it also regards the (1+1) EA with Best-of-µ initialization (instead of just initializing with a random individual), the approach of [START_REF] Böttcher | Optimal fixed and adaptive mutation rates for the LeadingOnes problem[END_REF] has the advantage that it also allows to determines the distribution of the runtime (this was first noted in [START_REF] Doerr | A method to derive fixed budget results from expected optimisation times[END_REF] and was formally proven in [START_REF] Doerr | Better Runtime Guarantees via Stochastic Domination[END_REF]). The work [START_REF] Böttcher | Optimal fixed and adaptive mutation rates for the LeadingOnes problem[END_REF] also shows that the often recommended mutation rate of p = 1/n is not optimal. A runtime smaller by 16% can be obtained from taking p = 1.59/n and another 12% can be gained by using a fitness-dependent mutation rate.

Dynamic Parameter Choices

While it is clear that EAs with parameters changing during the run of the algorithm (dynamic parameter settings) can be more powerful than those only using static parameter settings, only recently considerable advantages of dynamic choices could be demonstrated by mathematical means (for discrete optimization problems; in continuous optimization, step size adaptation is obviously necessary to approach arbitrarily closely a target point). To describe the different ways to dynamically control parameters and to summarize the most relevant works, we use in the following the taxonomy proposed in [START_REF] Doerr | Theory of Parameter Control Mechanisms for Discrete Black-Box Optimization: Provable Performance Gains Through Dynamic Parameter Choices[END_REF], which distinguishes between state-dependent, success-based, learning-inspired, and endogenous, parameter choices.

State-Dependent Parameter Control

In the classification of [START_REF] Doerr | Theory of Parameter Control Mechanisms for Discrete Black-Box Optimization: Provable Performance Gains Through Dynamic Parameter Choices[END_REF], state-dependent parameter control subsumes those mechanisms that depend only on the current state of the search process, e.g., the current population, its fitness values, its diversity, but also a time or iteration counter. Hence this subsumes the classic deterministic category in [START_REF] Endre Eiben | Parameter control in evolutionary algorithms[END_REF] and all other parameter setting mechanisms which determine the current parameter values via a pre-defined function that maps algorithm states to parameter values, possibly in a randomized manner. All these mechanisms require the user to precisely specify how the parameter value depends on the current state and as such need a substantial understanding of the problem to be solved.

The first to rigorously analyze this scheme in the context of evolutionary computation are Jansen and Wegener [START_REF] Jansen | On the analysis of a dynamic evolutionary algorithm[END_REF]. They regard the performance of the (1+1) EA which uses in iteration t the mutation rate k/n, where k ∈ {1, 2, . . . , 2 log 2 n -2 } is chosen such that log 2 (k) ≡ t -1 (mod log 2 n -1). In other words, they cyclically use the mutation rates 1/n, 2/n, 4/n, . . . , K/n, where K is the largest power of two that is less than n/2. Jansen and Wegener demonstrate that there exists an example function where this dynamic EA significantly outperforms the (1+1) EA with any static mutation rate. However, they also observe that for many classic problems, this EA is slower by a factor of Θ(log n).

After the first the time-dependent parameter scheme, Böttcher, Doerr, and Neumann conducted a runtime analysis for a fitness-dependent parameter in [START_REF] Böttcher | Optimal fixed and adaptive mutation rates for the LeadingOnes problem[END_REF]. They proposed to use the mutation rate of 1/(Lo(x) + 1) for the optimization of the LeadingOnes test function. They proved that with this choice, the runtime of the (1+1) EA improves to roughly 0.68n 2 compared to a time of 0.86n 2 stemming from the classic mutation rate 1/n or a runtime of 0.77n 2 stemming from the asymptotically optimal static rate of approximately 1.59/n.

For the (1 + (λ, λ)) genetic algorithm (GA), a fitness-dependent offspring population size of order λ = Θ( n/d(x) ) was suggested in [START_REF] Doerr | From black-box complexity to designing new genetic algorithms[END_REF], where d(x) is the fitness-distance of the parent individual to the optimum. This choice improves the optimization time (number of fitness evaluations until the optimum is found) on OneMax from Θ(n log(n) log log log(n)/ log log(n) ) stemming from the optimal static parameter choice to O(n), as was proven in [START_REF] Doerr | Optimal Static and Self-Adjusting Parameter Choices for the (1 + (λ, λ)) Genetic Algorithm[END_REF]. Since in this adaptive algorithm the mutation rate p is functionally dependent on the offspring population size, namely via p = λ/n, the dynamic choice of λ is equivalent to a fitness-dependent mutation rate of 1/ nd(x).

In the aforementioned work by Badkobeh et al. [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF], a fitness-dependent mutation rate of max

O n log log λ log λ + n log n λ to O n log λ + n log n λ
for OneMax problem. They also proved that it is the asymptotically best-possible runtime all λ-parallel mutation-based unbiased black-box algorithms. We notice here that this complexity is exactly what we aim at in Chapter 4 and Chapter 5 but using self-adjusting and self-adaptative parameter control schemes. We will discuss such schemes below.

Success-Based Parameter Control

As one important type of self-adjusting parameter control mechanisms, successbased parameter settings are classified as all those mechanisms which change the parameters from one iteration to the next, based on the outcome of the iteration. This includes in particular multiplicative update rules which change parameters by constant factors depending on whether the iteration was considered a success or not.

The last years have produced a profound understanding of success-based parameter choices. The first to perform a mathematical analysis were [START_REF] Lässig | Adaptive population models for offspring populations and parallel evolutionary algorithms[END_REF], who considered the (1+λ) EA and a simple parallel island model together with two self-adjusting mechanisms for population size or island number, including halving or doubling it depending on whether the current iteration led to an improvement or not. These mechanisms were proven to give significant improvements of the "parallel" runtime (number of generations) on various test functions without increasing significantly the "sequential" runtime (number of fitness evaluations).

In [START_REF] Doerr | Optimal parameter choices through self-adjustment: applying the 1/5-th rule in discrete settings[END_REF] it was shown by empirical means that the fitness-dependent choice of λ for the (1 + (λ, λ)) GA can also be found in a self-adjusting way. To this aim, another success-based mechanism was proposed, which imitates the 1/5-th rule from evolution strategies. It was later proven to yield indeed an optimal linear runtime on OneMax [START_REF] Doerr | Optimal Static and Self-Adjusting Parameter Choices for the (1 + (λ, λ)) Genetic Algorithm[END_REF]. With some modifications, the self-adjusting mechanism also works on random satisfiability problems [START_REF] Buzdalov | Runtime Analysis of the (1 + (λ, λ)) Genetic Algorithm on Random Satisfiable 3-CNF Formulas[END_REF]. For the problem of optimizing an r-valued OneMax function, a self-adjustment of the step size inspired by the 1/5-th rule was found to find the asymptotically best possible runtime in [START_REF] Doerr | Provably optimal self-adjusting step sizes for multi-valued decision variables[END_REF]. Empirical results show that similar mechanisms work very well also to control the mutation rate of the (1+1) EA optimizing OneMax and LeadingOnes [START_REF] Doerr | On the Effectiveness of Simple Success-Based Parameter Selection Mechanisms for Two Classical Discrete Black-Box Optimization Benchmark Problems[END_REF]. Our (1+λ) EA in Chapter 4 uses a success-based parameter control mechanism, of a different and novel type. The idea is that the mutation rate is updated according to the rate which generates the best offspring. We add one modification to this basic idea, by taking the winner's rate only with probability a half and else modifying the mutation rate randomly to a rate used in that iteration.

Learning-Inspired Parameter Control

In contrast to the success-based parameter control mechanisms, learning-inspired parameter control mechanisms are classified as all those schemes which aim at exploiting more than one iteration.

To allow such learning mechanisms to also adapt quickly to changing environments, older information is taken into account to a lesser extend than more recent ones. This can be achieved by only regarding information from (static or sliding) time windows or by discounting the importance of older information via weights that decrease (usually exponentially) with the anciency of the data.

Most experimental results within the evolutionary computation context borrow tools from machine learning. The upper confidence bound (UCB)-algorithm originally proposed in [START_REF] Fischer | Finite-time analysis of the multiarmed bandit problem[END_REF] is an example. It plays an important role in machine learning, as it is one of the few strategies that can be proven to behave optimally in a classical operator selection problem.

Our learning-based RLS in Chapter 3 is the only theoretical result so far for a learning-inspired parameter control mechanism in the context of RSHs.

Endogenous Parameter Control (Self-adaptation)

Endogenous parameter control corresponds to the self-adaptive parameter control mechanisms in the taxonomy of [START_REF] Endre Eiben | Parameter control in evolutionary algorithms[END_REF]. Such mechanisms are classified as all those schemes where the parameter is encoded in the genome and thus subject to variation and selection. The understanding of self-adaptation is still very limited. The only theoretical work on this topic [START_REF] Dang | Self-adaptation of mutation rates in non-elitist populations[END_REF], however, is promising and shows examples where self-adaptation can lead to significant speed-ups for non-elitist evolutionary algorithms.

Our (1,λ) EA in Chapter 5 is the first non-artificial example for the use of selfadaptation in the theory literature. The mutation strength and bit string is combined together in an individual. Therefore, parameter is adapted automatically when selecting the best offspring.

Chapter 2

Preliminaries

In this chapter we formally define the black-box setting and the algorithm analyzed in this work. We present some fundamental probabilities tools for the analysis including drift theorems, Chernoff bounds, and occupation probability.

Black-box Complexity

The black-box complexity of a problem is the minimum average number of fitness evaluations that a black-box optimization algorithm (that is, an algorithm that has only access to the objective function, but not to an explicit problem description) needs in order to find an optimal solution. This notion was introduced in [DJW06] and has attracted significant attention in the past years. In particular, black-box complexity insight has been used to design better algorithms [START_REF] Doerr | From black-box complexity to designing new genetic algorithms[END_REF], and specific black-box models (allowing only a restricted class of black-box algorithms) have been proposed to understand particular properties of evolutionary algorithms and to better reflect how typical evolutionary algorithms look like.

In this work, we build on the unary unbiased black-box complexity [START_REF] Per | Black-Box Search by Unbiased Variation[END_REF], which is a reasonable model for mutation-based search heuristics. In simple words, a unary unbiased black-box algorithm is allowed (i) to sample random search points and (ii) to generate new search points from applying unbiased mutation operators to previously found search points. We first limit the number of search points that are used to generate the offspring. By looking at unary variation operators, we consider using only one search point to produce new search point. Moreover, unbiased means that the operator is invariant under automorphisms of the hypercube, so in particular, it is not allowed to prefer certain bit-positions or bit-values. Furthermore, all selection operations have to be independent of the bit-string representation of the individual. The algorithms follows the blueprint described in Algorithm 1.

The unary unbiased black-box complexity of OneMax is the smallest expected number of function evaluations that any algorithm following the structure of Algorithm 1 exhibits on this problem. In line 9 of Algorithm 1 a unary unbiased variation operator is asked for. In the context of optimizing pseudo-Boolean functions, a unary operator is an algorithm that is build upon a family (p(• | x)) x∈{0,1} n of probability distributions over {0, 1} n . Given some input x it outputs a new string that it samples from the distribution p(• | x). A unary operator is unbiased if all members of its underlying family of probability distributions are symmetric with respect to the bit positions [n] = [1..n] where notation [l..r] is defined as the set of integers from l to r inclusively and the bit values 0 and 1 (cf. [START_REF] Per | Black-Box Search by Unbiased Variation[END_REF] for a discussion).

Evolutionary Algorithms

All mutation-based (µ + λ) or (µ, λ) EAs with standard bit mutation or 1-bit flips belong to the class of unbiased black-box algorithms. In this work, we analyze the performance of (1,λ) EA and (1+λ) EA on OneMax problem. In each generation, λ parallel offspring are generated using the same single parent. Below are the structures of these two algorithms. The only difference between the (1+λ) EA and the (1,λ) EA is whether the parent is updated to the best offspring when all offspring are worse than the parent. The (1+λ) EA takes the best search point among λ offspring and the parent itself, whereas the (1,λ) EA simply replaced the parent by the winner of λ offspring. We notice that the (1+λ) EA is an elitist algorithm since the fitness distance is nonincreasing. However, the (1,λ) EA is non-elitist and may result in exponential runtime due to insufficient population size. We shall analyze the performance of the above two algorithms on the OneMax in Chapter 4 and Chapter 5 respectively.

Randomized Local Search

Randomized Local Search is very similar to the simplest evolutionary algorithm

(1 + 1) EA. They both generate one search point in each iteration and do selection between the parent and its single offspring. The only difference is that, the (1 + 1) EA generates offspring using standard bit mutation whereas RLS generates offspring from the neighborhood. Assuming using mutation strength of r for both, the (1 + 1) EA flips every bit independently with probability r/n, whereas the RLS chooses r bits uniformly at random from all n bits and flip exactly these bits. Below is the structure of RLS.

Algorithm 4 RLS with static mutation strength r for minimizing f : {0, 1} n → R Select x uniformly at random from {0, 1} n for t ← 1, 2, . . . do Choose a r-subset S ⊂ [1.

.n] uniformly at random. Create x * by flipping bits in S in a copy of x.

if f (x * ) ≤ f (x) then x ← x * .
Classic RLS applies static mutation rate. By taking r = 1, solving the One-Max problem is reduced to a coupon collect problem which has a known complexity Θ(n ln n). We prove in Chapter 3 that RLS with fitness dependent mutation rate is the nearly optimal unary unbiased black-box algorithm apart from an additional o(n) term. To analyze the runtime impact caused by different mutation strengths, we introduce drift theorems which relate expected progress to expected runtime.

Drift Theorems

The main tool in our work is drift analysis, a well-established method in the theory of randomized search heuristics. Drift analysis tries to translate information about the expected progress an algorithm does into information about the expected runtime. Drift analysis was introduced to the field in the seminal work of He and Yao [START_REF] He | A study of drift analysis for estimating computation time of evolutionary algorithms[END_REF]. They proved the following additive drift theorem, which assumes a uniform bound on the expected progress.

Theorem 2.1 (Additive drift theorem [START_REF] He | A study of drift analysis for estimating computation time of evolutionary algorithms[END_REF]). Let (X t ) t≥0 be a sequence of nonnegative random variables over a finite state space in R. Let T be the random variable that denotes the earliest point in time t ≥ 0 such that

X t = 0. If there exist c, d > 0 such that c ≤ E (X t -X t+1 | T > t) ≤ d, then X 0 d ≤ E (T | X 0 ) ≤ X 0 c .
A uniform bound on the drift is often not convenient, since the progress of many algorithms slows down the closer one is to the optimum. For this reason, multiplicative drift assuming a progress proportional to the distance to the optimum was proposed in [START_REF] Doerr | Multiplicative Drift Analysis[END_REF]. While it is often a good tool for the analysis of randomized search heuristic on the OneMax test function and related problems, for the very precise bound we aim at in Chapter 3 it does not suffice to approximate the true drift behavior via a linear progress estimate. For this reason, we resort to the most general technique known in the area of drift analysis, which is called variable drift, and which assumes no particular behavior of the progress. Variable drift was independently developed in [START_REF] Mitavskiy | Theoretical analysis of local search strategies to optimize network communication subject to preserving the total number of links[END_REF] and [START_REF] Johannsen | Random combinatorial structures and randomized search heuristics[END_REF]. The latter result reads as follows.

Theorem 2.2 (Johannsen's Theorem [START_REF] Johannsen | Random combinatorial structures and randomized search heuristics[END_REF]). Let (X t ) t≥0 be a sequence of nonnegative random variables over a finite state space in S ⊂ R and let x min = min{x ∈ S : x > 0}. Furthermore, let T be the random variable that denotes the earliest point in time t ≥ 0 such that X t = 0. Suppose that there exists a continuous and monotonically increasing function h : R + 0 → R + 0 such that for all t < T it holds that

E (X t -X t+1 | X t ) ≥ h(X t ). Then E (T | X 0 ) ≤ x min h(x min ) + X 0 x min 1 h(x) dx.
The variable drift theorem is often applied in the special case of additive drift in discrete spaces: assuming

E(X t -X t+1 | X t = x; X t > 0) ≥ ε for some constant ε, one obtains E(T | X 0 = x ) ≤ x /ε.
Since we will make frequent use of it in the following sections as well, we will also give the version of the Multiplicative Drift Theorem for upper bounds, due to [START_REF] Doerr | Multiplicative Drift Analysis[END_REF]. Again, this is implied by the previous variable drift theorem.

Theorem 2.3 (Multiplicative drift [START_REF] Doerr | Multiplicative Drift Analysis[END_REF]). Let (X t ) t≥0 be random variables describing a Markov process over a finite state space S ⊆ R + 0 and let x min := min{x ∈ S | x > 0}. Let T be the random variable that denotes the earliest point in time t ≥ 0 such that X t = 0. If there exist δ > 0 such that for all x ∈ S with Pr(

X t = x) > 0 we have E(X t -X t+1 | X t = x) ≥ δx ,
then for all x ∈ S with Pr(X 0 = x ) > 0,

E(T | X 0 = x ) ≤ 1 + ln x x min δ .
We recall that our search space is discrete. Therefore by redoing the proof of Theorem in [START_REF] Johannsen | Random combinatorial structures and randomized search heuristics[END_REF], we derive a discrete drift theorem, which uses the elementary idea to approximate a step function by continuous functions.

Theorem 2.4 (Discrete variable drift, upper bound). Let (X t ) t≥0 be a sequence of random variables in [0..n] and let T be the random variable that denotes the earliest point in time t ≥ 0 such that X t = 0. Suppose that there exists a monotonically increasing function h : {1, . . . , n} → R + 0 such that

E (X t -X t+1 | X t ) ≥ h(X t )
holds for all t < T . Then

E (T | X 0 ) ≤ X 0 i=1 1 h(i) .
Proof. For all 0 < ε < 1, define a function

h ε : [1, n] → R + by h ε (x) := h( x ) + x-x ε h( x ) -h( x ) for 0 < x -x ≤ ε, h( x ) for ε < x -x , (2.1)
The continuous monotone function h ε satisfies E(X t -X t+1 | X t ) ≥ h ε (X t ) for all t < T . We compute

X 0 1 1 h ε (x) dx ≤ X 0 i=2 ε h(i -1) + 1 -ε h(i) = ε h(1) - ε h(X 0 ) + X 0 i=2 1 h(i) .
Hence by Theorem 2.2, we have

E(T | X 0 ) ≤ ε h(1) -ε h(X 0 ) + X 0 i=1 1 h(i)
for all ε > 0, which proves the claim.

Inspired by Theorem 2.1, it is intuitive to think that there is a lower bound variable drift theorem which has similar structure as the upper bound variable drift theorem. Theorem 2.5 in [START_REF] Doerr | Sharp bounds by probability-generating functions and variable drift[END_REF] shows how lower bounds on the expected first hitting time can be derived from upper bounds on the drift. As a main difference to the upper bound case, it is now required that the process with probability one in each round does not move too far towards the target (first condition of the theorem below).

Theorem 2.5 (Variable drift, lower bound [START_REF] Doerr | Sharp bounds by probability-generating functions and variable drift[END_REF]). Let (X t ) t≥0 be a decreasing sequence of non-negative random variables over a finite state space in S ⊂ R and let x min = min{x ∈ S : x > 0}. Furthermore, let T be the random variable that denotes the earliest point in time t ≥ 0 such that X t = 0. Suppose that there exists two continuous and monotonically increasing function c, h : R

+ 0 → R + 0 such that 1. X t+1 ≥ c(X t ), 2. E(X t -X t+1 | X t ) ≤ h(c(X t )). Then E (T | X 0 ) ≥ x min h(x min ) + X 0 x min 1 h(x) dx.
The first condition of the theorem above, that with probability one no progress beyond a given limit is made, is a substantial restriction to the applicability of the theorem, in particular, when working with evolutionary algorithms, where often any parent can give birth to any offspring (though usually with very small probability). In [START_REF] Doerr | Sharp bounds by probability-generating functions and variable drift[END_REF], this problem was overcome with the simple argument that a progress of more than √ x from a search point with fitness distance x occurs with such a small probability that it does with high probability not occur in a run of typical length.

For the precise bounds that we aim at, we show a different version of the lower bound variable drift theorem, which allows larger jumps, if only they occur sufficiently rarely. The way to such a theorem is, in fact, quite easy. Instead of using a blunt union bound over all bad events of too large jumps (as sketched above), we take these large jumps into account when computing the (additive) drift in a proof analogous to the one of [START_REF] Doerr | Sharp bounds by probability-generating functions and variable drift[END_REF]. This idea was already used in [START_REF] Gießen | Optimal Mutation Rates for the (1+λ) EA on OneMax[END_REF], where an essentially similar, but slightly more technical drift theorem for random processes in arbitrary domains is derived. Note here that in contrast to [START_REF] Gießen | Optimal Mutation Rates for the (1+λ) EA on OneMax[END_REF] we restrict ourselves to processes over the non-negative integers.

Theorem 2.6 (Discrete variable drift, lower bound). Let (X t ) t≥0 be a sequence of decreasing random variables in [0..n] and let T be the random variable that denotes the earliest point in time t ≥ 0 such that X t = 0. Suppose that there exists two monotonically increasing functions c : [n] → [0..n] and h : [0..n] → R + 0 , and a constant 0 ≤ p < 1 such that 1. X t+1 ≥ c(X t ) with probability at least 1p for all t < T ,

2. E(X t -X t+1 | X t ) ≤ h(c(X t )) holds for all t < T . Let g : [0..n] → R + 0 be the function defined by g(x) = x-1 i=0 1 h(i) . Then E(T | X 0 ) ≥ g(X 0 ) - g 2 (X 0 )p 1 + g(X 0 )p .
Proof. The function g is strictly monotonically increasing. We have g(X t ) = 0 if and only if X t = 0. Using condition 1 and the monotonicity of h, in the case X t+1 ≥ c(X t ) we have

g(X t ) -g(X t+1 ) = Xt-1 i=X t+1 1 h(i) ≤ X t -X t+1 h(X t+1 ) ≤ X t -X t+1 h(c(X t )) ,
and otherwise

g(X t ) -g(X t+1 ) ≤ g(X t ) ≤ g(X 0 ). Using inequality E(X t -X t+1 | X t ) ≤ E(X t -X t+1 | X t+1 ≥ c(X t )) and condition 2, we have E (g(X t ) -g(X t+1 ) | g(X t )) ≤ E X t -X t+1 h(c(X t )) | X t+1 ≥ c(X t ) (1 -p) + g(X 0 )p ≤ 1 + g(X 0 )p.
Applying the additive drift theorem 2.1 to g(X t ) t≥0 , we obtain

E (T | X 0 ) = E (T | g(X 0 )) ≥ g(X 0 ) 1 + g(X 0 )p = g(X 0 ) - g 2 (X 0 )p 1 + g(X 0 )p .
To apply the drift theorem above (or Theorem 2.5) one needs to guess a suitable function h such that h • c is an upper bound for the drift. The following simple reformulation overcomes this difficulty by making h(x) simply an upper bound for the drift from a state x. This also makes the result easier to interpret. The influence of large jumps, as quantified by c, now is that the runtime bound is not anymore the sum of all h(x) -1 as in the upper bound theorem, but of all h(µ(x)) -1 , where µ(x) is the largest point y such that c(y) ≤ x. So in simple words, we have to replace the drift at x pessimistically by the largest drift among the points from which we can go to x (or further) in one round with probability more than p. Theorem 2.7 (Discrete variable drift, lower bound). Let (X t ) t≥0 be a sequence of decreasing random variables in [0..n] and let T be the random variable that denotes the earliest point in time t ≥ 0 such that X t = 0. Suppose that there exists two functions c : {1, . . . , n} → [0..n] and monotonically increasing h : [0..n] → R + 0 , and a constant 0 ≤ p < 1 such that 1. X t+1 ≥ c(X t ) with probability at least 1p for all t < T ,

2. E(X t -X t+1 | X t ) ≤ h(X t ) holds for all t < T . Let µ : [0..n] → [0.
.n] be the function defined by µ(x) = max{i|c(i) ≤ x} and g : [0..n] → R + 0 be the function defined by g(

x) = x-1 i=0 1 h(µ(i)) . Then E(T | X 0 ) ≥ g(X 0 ) - g 2 (X 0 )p 1 + g(X 0 )p . Proof. Let ĉ : [0..n] → [0.
.n], r → ĉ(r) := min{i|µ(i) ≥ r}. By definition, ĉ is monotonically increasing. Let r ∈ [n]. Since r ∈ {i|c(i) ≤ c(r)}, we have µ(c(r)) ≥ r, which implies c(r) ∈ {i|µ(i) ≥ r}. Hence ĉ(r) ≤ c(r). This shows that we have X t+1 ≥ ĉ(X t ) for all t < T . The definition of ĉ implies that µ( ĉ(r)) ≥ r. Together with the monotonicity of h, we obtain E(X t -X t+1 | X t ) ≤ h(X t ) ≤ h(µ( ĉ(X t ))). Let ĥ : [0..n] → R + 0 , r → ĥ(r) := h(µ(r)). It is easy to see from the definition that µ is monotonically increasing, therefore, ĥ is also monotonically increasing and it satisfies E(X t -X t+1 | X t ) ≤ ĥ( ĉ(X t )). Applying Theorem 2.6 to ĥ and ĉ shows the claim.

Chernoff Bounds

In probability theory, the Chernoff bound gives exponentially decreasing bounds on tail distributions of sums of independent random variables. It is a sharper bound than the known first or second moment based tail bounds such as Markov's inequality or Chebyshev inequality, which only yield power-law bounds on the tail decay. We notice that the Chernoff bound requires that the variates be independent. However, the Chernoff bound also holds when the variates are dependent, but the sums follows a hypergeometric distribution.

For reasons of self-containedness, we state the well-known multiplicative Chernoff bounds, additive Chernoff bounds, and a lesser known additive Chernoff bound that is also known in the literature as Bernstein's inequality. These bounds can be found, e.g., in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF].

Theorem 2.8 (Bernstein's inequality, Chernoff bounds). Let X 1 , . . . , X n be independent random variables and

X = n i=1 X i . 1. Let b be such that E(X i ) -b ≤ X i ≤ E(X i ) + b for all i = 1, . . . , n. Let σ 2 = n i=1 Var(X i ) = Var[X]. Then for all ∆ ≥ 0, Pr(X ≥ E(X) + ∆) ≤ exp - ∆ 2 2(σ 2 + 1 3 b∆) .
2. Assume that for all i = 1, . . . , n, the random variable

X i takes values in [0, 1] only. Then (a) Pr(X ≤ (1 -δ)E(X)) ≤ e -δ (1-δ) 1-δ E(X) ≤ exp δ 2 E(X) -2 for all 0 ≤ δ ≤ 1, (b) Pr(X ≥ (1 + δ)E(X)) ≤ e δ (1+δ) 1+δ E(X) ≤ exp -δ 2 E(X) 2+δ for all δ ≥ 0, (c) Pr(X ≤ E(X) -λ) ≤ exp -2λ 2 /n for all λ > 0, (d) Pr(X ≥ E(X) + λ) ≤ exp -2λ 2 /n for all λ > 0.
3. All bounds in item 2 are valid also if X is a random variable with hypergeometric distribution.

Occupation Probabilities

In Chapter 4 and Chapter 5, we design a scheme for evolutionary algorithms to adjust the mutation strength automatically based on the performance of all λ offspring. Thus, we will be analyzing two depending stochastic processes: the random decrease of fitness distance and the random change of the mutation rate. Often, we will prove by drift analysis that the rate is drifting towards values that yield an almost-optimal distance decrease. However, once the rate has drifted towards such values, we would also like the rates to stay in the vicinity of these values in subsequent steps. To this end, we state two occupation theorems here. One is Theorem 7 from [START_REF] Kötzing | 1+1) EA on generalized dynamic OneMax[END_REF], which assumes that the process in each step moves at most some constant distance. The other is Theorem 2.3 in [START_REF] Hajek | Hitting-time and occupation-time bounds implied by drift analysis with applications[END_REF] which is a stronger because it considers the strong drift toward the target. Theorem 2.9 (Theorem 7 in [START_REF] Kötzing | 1+1) EA on generalized dynamic OneMax[END_REF]). Let a Markov process (X t ) t≥0 on R + 0 , where |X t -X t+1 | ≤ c, with additive drift of at least d towards 0 be given (i. e., E(X t -X t+1 | X t ; X t > 0) ≥ d), starting at 0 (i.e. X 0 = 0). Then we have, for all t ∈ N and b

∈ R + 0 , Pr(X t ≥ b) ≤ 2e 2d 3c (1-b/c) .
Theorem 2.10 (Theorem 2.3 in [START_REF] Hajek | Hitting-time and occupation-time bounds implied by drift analysis with applications[END_REF]). Suppose that (F k ) k≥0 is an increasing family of sub-σ-fields of F and

(Y k ) k≥0 is adapted to (F k ). If E (e η(Y k+1 -Y k ) ; Y k > a | F k ≤ ρ and E e η(Y k+1 -1) ; Y k ≤ a | F k ≤ D, then Pr (Y k ≥ b | F 0 ) ≤ ρ k e η(Y 0 -b) + 1 -ρ k 1 -ρ De η(a-b) .
We rewrite the above two theorems into the following lemmas respectively such that they can be directly applied.

Lemma 2.11. If there is a point a ≥ 4 such that Pr(r t+1 < r t | r t > a) ≥ 1/2 + ε for some constant ε > 0, then for all t ≥ min{t | r t ≤ a} and all b ≥ 2 it holds Pr(r t ≥ a • 2 b+1 ) ≤ 2e -2bε/3 . Proof. Apply Lemma 2.9 to the process X t := max{0, log 2 (r t /a) }. Note that this process is on N 0 , moves by an absolute value of at most 1 and has drift E(X t -X t+1 | X t ; X t > 0) ≥ 2ε. We use c := 1 and d := 2ε in the theorem and estimate 1b ≤ -b/2. Lemma 2.12. Consider a stochastic process X t , t ≥ 0, on R such that for some p ≤ 1/25 the transition probabilities for all t ≥ 0 satisfy Pr(X t+1 ≥ X t + a | X t > 1) ≤ p a+1 for all a ≥ -1/2 as well as Pr(X t+1 ≥ a + 1 | X t ≤ 1) ≤ p a+1 for all a ≥ 0. If X 0 ≤ 1 then for all t ≥ 1 and k > 1 it holds that

Pr(X t ≥ 1 + k) ≤ 11 (ep) k .
Proof. We aim at applying Theorem 2.10. There are two cases depending on X t : for X t ≤ 1, using the monotonicity of e λ(X t+1 -1) with respect to X t+1 -1, we obtain

D(p, λ) := E(e λ(X t+1 -1) | X t ≤ 1) ≤ E(e λ max{ X t+1 -1 ,0} | X t ≤ 1) = e 0 Pr(X t+1 ≤ 1 | X t ≤ 1) + ∞ a=1 e λa Pr(a < X t+1 ≤ a + 1 | X t ≤ 1) ≤ e 0 + ∞ a=1 e λa Pr(X t > a | X t ≤ 1),
using the assumption that Pr(X t+1 ≥ a + 1 | X t ≤ 1) ≤ p a+1 for all a ≥ 0 then

D(p, λ) ≤ 1 + ∞ a=1 e λa p a = 1 + e λ p 1 -e λ p ;
and for X t > 1, using the monotonicity of e λ(X t+1 -Xt) respect to X t+1 -X t , we have

ρ(p, λ) := E(e λ(X t+1 -Xt) | X t > 1) ≤ E(e λ max{ 2(X t+1 -Xt) /2,-1/2} | X t > 1) = e -λ/2 Pr X t+1 -X t ≤ - 1 2 | X t > 1 + ∞ a=0 e λa/2 Pr a -1 2 < X t+1 -X t ≤ a 2 | X t > 1 ≤ e -λ/2 + ∞ a=0 e λa/2 Pr X t+1 -X t > a -1 2 | X t > 1 , using the assumption that Pr(X t+1 ≥ X t + a | X t > 1) ≤ p a+1 for all a ≥ -1/2 then ρ(p, λ) := e -λ/2 + ∞ a=0 e λa/2 p (a+1)/2 = p 1/2 (e λ p) 1/2 + p 1/2 1 -(e λ p) 1/2 .
Using λ := ln(1/(ep)) such that e λ p = 1/e, we have [START_REF] Hajek | Hitting-time and occupation-time bounds implied by drift analysis with applications[END_REF] yields with a := 1 and b

ρ := ρ(p, λ) ≤ e 1/2 p 1/2 + p 1/2 1 -e -1/2 ≤ e 1/2 5 + 1/5 1 -e -1/2 < 0.84, D := D(p, λ) ≤ 1 + (1/e)/(1 -1/e) < 1.6. Theorem 2.3, inequality (2.8) in
:= 1 + k that Pr(X t ≥ 1 + k | X 0 ) ≤ ρ t e -λ(1+k-X 0 ) + 1 1 -ρ De -λk ≤ (ep) k + 1.6 1 -0.84 (ep) k = 11(ep) k .
For the simpler case of a random process that runs on the positive integers and that has a strong drift to the left, we have the following estimate for the occupation probabilities.

Lemma 2.13. Consider a random process defined on the positive integers 1, 2, . . . . Assume that from each state i different from 1, only the two neighboring states i -1 and i + 1 can be reached (and there is no self-loop on state i). From state 1, only state 2 can be reached and the process can stay on state 1. Let p i be an upper bound for the transition probability from state i to state i + 1 (valid in each iteration regardless of the past). Assume that p i-1 ≥ p i 1p i holds for all i ≥ 2. Assume that the process starts in state 1. Then at all times, the probability to be in state i is at most

q i := i-1 j=1 p j 1 -p j ,
where as usual we read the empty product as q 1 = 1.

Proof. The claimed bound on the occupation probabilities is clearly true at the start of the process. Assume that it is true at some time. By this assumption and the assumptions on the process, the probability to be in state i ≥ 2 after one step is at most

q i-1 p i + q i+1 = q i-1 p i + p i-1 1 -p i-1 p i 1 -p i ≤ q i-1 p i 1 -p i + p i-1 1 -p i-1 p i 1 -p i = q i-1 p i (1 -p i-1 ) (1 -p i-1 )(1 -p i ) + p i-1 1 -p i-1 p i 1 -p i ≤ q i-1 p i (1 -p i-1 )(1 -p i ) ≤ q i-1 p i-1 1 -p i-1 = q i .
Trivially, the probability to be in state 1 after one step is at most q 1 = 1. Hence, by induction over time, we see that q i is an upper bound for the probability to be in state i at all times.

Useful Equations and Inequalities

In this section, we list frequently used equations and estimations. Lemma 2.14 provides some useful inequalities involving logarithmic function and Lemma 2.15 is about binomial coefficient.

Lemma 2.14.

1. For all x > 0, we have ln x ≤ x/e.

2. For all x ∈ R, we have 1

+ x ≤ e x . 3. For all 0 ≤ x ≤ 2/3, we have 1 -x ≥ e -x-x 2 .
4. For all 0 ≤ x ≤ 1/2, we have 1x ≥ e -3x/2 . 5. Weierstrass product inequality: For all p 1 , . . . , p n ∈ [0, 1],

1 - n i=1 p i ≤ n i=1
(1p i ).

Proof. Since (ln xx/e) = 1/x -1/e, x > 0, then (e, 0) is the maximum point of ln xx/e, x > 0. Thus part 1 holds. We notice that (1 + xe x ) = 1e x , then (0, 0) is the maximal point of 1 + xe x . Therefore part 2 holds.

For the proof of part 3, let f (x) = 1xe -x-x 2 for 0 ≤ x ≤ 2/3. Then

f (x) = (1 + 2x)e -x-x 2 -1 and f (x) = (1 -4x -4x 2 )e -x-x 2
. We notice that f (x) has only one zero point between 0 and 2/3. Let x 0 denote the zero point. Thus f (x) is positive before x 0 , and then becomes negative after x 0 . Using the fact f (0) = 0 and f (2/3) < 0, we can easily see that f (x) first increases from 0 to f (x 0 ) > 0, and then decreases below 0. This means the minimum of f (x) is attained at 0 or 2/3. Due to the fact that f (0) = 0 and f (2/3) > 0, the first inequality in part 3 holds. For the proof of part 4, We notice that (1xe -3x/2 ) = -1 + (3/2)e -3x/2 . It is positive for 0 < x < (2/3) ln(3/2) and negative for (2/3) ln(3/2) < x ≤ 1/2. Since 1 -0 = e 0 and 1 -1/2 > e -3/4 , the statement holds.

Using the fact that p n ≥ ( n-1 i=1 (1p i ))p n , part 5 is easily derived by doing induction over n. Lemma 2.15. Consider m, n ∈ N 0 and m ≤ n. We abbreviate (n)

m := n(n - 1) . . . (n -m + 1) = m-1 i=0 n -i. 1. ( n m ) = n! m!(n-m)! = (n)m m! ≥ n m m and ( n m ) = ( n-1 m-1 ) + ( n-1 m ). 2. (n -m + 1) m ≤ (n) m ≤ n m . 3. ( n m ) = ( n n-m ), ( n m )m = n( n-1 m-1 ), and ( n m )(n -i) = n( n-1 m ).
In our analysis, we deal with binomial distributions frequently. Here we list some results from [START_REF] Doerr | Probabilistic Tools for the Analysis of Randomized Optimization Heuristics[END_REF]Lemma 10.20] and [DD18a, Lemma 1].

Lemma 2.16. Let n ∈ N, p ∈ [0, 1], and µ = np . Let X ∼ Bin(n, p).

1. if 1/n < p < 1, then Pr(X > E(X) + 1) > 1/2 - n 2πµ(n-µ) . 2. if 1/n < p < 1 -1/n, then Pr(X > E(X) + 1) ≥ 0.037. 3. if 0.29/n < p, then Pr(X > E(X)) ≥ 1/4. 4. if k ∈ [0..n], then E(X | X ≥ k) ≤ E(X) + k.
Chapter 3

Precise Unary Unbiased Black-box Complexity

With the goal of starting a complexity theory targeting precise results, we analyze the unary unbiased black-box complexity of the OneMax benchmark function. It is known that the unary unbiased black-box complexity of OneMax is of order Θ(n log n) [START_REF] Per | Black-Box Search by Unbiased Variation[END_REF]. The simple randomized local search heuristic, a hillclimber flipping single random bits, is easily seen to have a runtime of at most n ln(n) + γn + 1 2 ≈ n ln(n) + 0.5772n where γ = 0.5772 . . . is the Euler-Mascheroni constant.

In this chapter, we show that the unary unbiased black-box complexity of One-Max is n ln(n)cn ± o(n) for a constant c for which we show 0.2539 < c < 0.2665. We propose a fitnessdependent randomized local search which achieves this complexity. We also show that such state-dependent parameter control can be replaced by a learning-inspired parameter control.

The proof of our results is in the following structures.

Maximizing Drift is Near-Optimal

Evolutionary algorithms build on the idea that iteratively maximizing the fitness is a good approach. This suggests to try to generate the offspring in a way that the expected fitness gain over the best-so-far solution is maximized. Clearly, this is not a successful idea for each and every problem, as easily demonstrated by examples like the distance and the trap functions [START_REF] Droste | On the analysis of the (1+1) Evolutionary Algorithm[END_REF], where the fitness leads the algorithm into a local optimum, or the difficult-to-optimize monotonic functions constructed in [START_REF] Doerr | Mutation rate matters even when optimizing monotone functions[END_REF][START_REF] Lengler | A General Dichotomy of Evolutionary Algorithms on Monotone Functions[END_REF], where the fitness leads to the optimum, but via a prohibitively long trajectory. Still, one might hope that for problems with a good fitness-distance correlation (and Om has the perfect fitness-distance correlation), maximizing the expected fitness gain is a good approach, and this is roughly what we are able to show.

More precisely, we cannot show that maximizing the expected fitness gain leads to the optimal unary unbiased black-box algorithm. It turns out this is also not true, even if we restrict ourselves to elitist algorithms, which cannot use tricks like minimizing the fitness and inverting the search point once the all-zero string was found. In fact, the elitist algorithm flipping in each iteration the number of bits that minimizes the expected remaining runtime is different from the drift-maximizing one. For all realistic problem sizes, however, the differences between the expected runtime of our drift maximizer and that of the optimal elitist algorithm are negligibly small [START_REF] Buskulic | [END_REF].

What we can prove, however, is that the algorithm which in each iteration takes the best-so-far solution and applies to it the unary unbiased mutation operator maximizing the expected fitness gain has an expected optimization time which exceeds the unary unbiased black-box complexity by at most a term of order O(n 2/3 log 9 n).

We note that this result, while natural, is quite difficult to obtain and relies on a number of properties particular to this process, in particular, the fact that we have a good structural understanding of the maximal drift.

Maximizing the Drift via the Right Fitness-Dependent Mutation Strength

Once we decided how to choose the parent individual, in principle it is easy to mutate it in such a way that the drift is maximized. Since any unary unbiased mutation operator can be seen as a convex combination of r-bit flip operators, r ∈ [0..n], and since the drift stemming from such an operator is the corresponding convex combination of the drifts stemming from the r-bit flip operators, we only need to determine, depending on the fitness of the parent, a value for r such that flipping r random bits maximizes the fitness gain over the parent. For a concrete value of n and a concrete fitness of the parent, one can compute the best value of r in time O(n 2 ).

We need some more mathematical arguments to (i) obtain a structural understanding of this r-value and (ii) to obtain a runtime estimate valid for all values of n. To this aim, we shall first argue that when the parent fitness distance d is at most ( 1 2ε)n for an arbitrarily small constant ε, the optimal drift is obtained from flipping a constant number r of bits (Lemma 3.14). For any constant r, the drift obtained from flipping r bits can be well approximated by a degree r polynomial in the relative fitness distance d/n (Theorem 3.16). By this, we overcome the dependence on n, that is, apart from this small approximation error we can, by regarding these polynomials, determine a function Ropt : [0, 1 2ε] → N such that for all n ∈ N and all d ∈ [0..( 1 2ε)n] the near-optimal number of bits to flip (that is, optimal apart from the approximation error) is Ropt (d/n). This Ropt is decreasing, that is, the closer we are to the optimum, the smaller is the optimal number of bits to flip. Interestingly, Ropt is never even, so the optimal number of bits to flip is always odd. These (and some more) properties allow to compute numerically the interval in which flipping r bits is optimal (for all odd r). From these we estimate the runtime by numerically approximating the integral describing the runtime via the resulting drifts. This gives approximations for both the runtime of our drift-maximizer and the unary unbiased black-box complexity, which are precise apart from an arbitrary small O(n) term.

We note that previous works have studied drift maximizing variants of RLS and the (1+1) EA by empirical means. For n = 100 Bäck [START_REF] Bäck | Self-adaptation in genetic algorithms[END_REF] computed the driftmaximizing mutation rates for different (1 + λ) and (1, λ)-EAs. Fialho and co-authors considered (1 + λ)-type RLS-variants which choose between either flippling exactly 1, 3, or 5 bits or applying standard bit mutation with mutation rate p = 1/n. A simple empirical Monte Carlo evaluation is conducted to estimate the average progress obtained by any of these four operators. [START_REF] Fialho | Extreme Value Based Adaptive Operator Selection[END_REF] studies the n = 1, 000dimensional OneMax function, and [START_REF] Fialho | Dynamic Multi-Armed Bandits and Extreme Value-Based Rewards for Adaptive Operator Selection in Evolutionary Algorithms[END_REF] the case n = 10, 000. None of the three mentioned works, however, further investigates the difference between the drift maximizing algorithm and the optimal (i.e., time-minimizing) one.

Fixed-Budget Result

Computing the runtime of our drift-maximizing algorithm, we observe that the fitness-dependent mutation strength gives a smallish-looking improvement of roughly 0.14n in the Θ(n log n) runtime. However, if we view our result in the fixed-budget perspective [START_REF] Jansen | Performance analysis of randomised search heuristics operating with a fixed budget[END_REF], then (after using the Azuma inequality in the martingale version to show sufficient concentration) we see that if we take the expected solution quality after a fixed number (budget) of iterations as performance measure, then our algorithm gives a roughly 13% smaller fitness distance to the optimum compared to the previousbest algorithm (provided that the budget is at least 0.2675n).

RLS with learning-inspired parameter control

The example of solving the OneMax problem shows that using a problem-specific optimal mutation strength can lead to a fair speed-up over standard bit mutation, however, with the risk of making the algorithm fail badly when choosing a wrong mutation strength. For this reason, we design a simple hill climber that autonomously tries to choose the optimal mutation rate by analyzing the past performance of the different mutation strengths. This aims both at exploiting that different problems ask for different mutation strengths and at exploiting that for a fixed problem the optimal mutation strength may change during the optimization process; a problem even less understood than what is the right problem-specific static mutation strength.

The heart of this work is making this effect mathematically precise for the One-Max function. For our new algorithm with self-adjusting mutation strength, we show that it essentially is able to find this optimal mutation schedule on the fly. More precisely, with high probability our algorithm always (apart from a lower-order fraction of the iterations) uses a mutation strength which gives an expected progress equal to the best possible progress (again, apart from lower order terms). Consequently, our algorithm has the same optimization time (apart from an o(n) additive lower order term) and the same asymptotic 13% superiority in the fixed budget perspective as the fitness-dependent algorithm.

We also experimentally analyze our new algorithm on the LeadingOnes and the MST problem. We observe that for suitable parameter settings, it clearly outperforms the (1+1) EA. Interestingly, it even beats the randomized local search (RLS) heuristic (flipping always one bit) for the LeadingOnes problem and the variant of RLS flipping one or two bits for the MST problem. This shows that for these problems a better performance can be obtained from a mutation strength that changes over time, and that our algorithm is able to find such superior fitness-dependent mutation strengths.

Problem Setting and Useful Tools

In this section we briefly describe the black-box setting regarded in this work, the unary unbiased model proposed by Lehre and Witt [START_REF] Per | Black-Box Search by Unbiased Variation[END_REF]. The variation operators that are admissible in this model are characterized in Lemma 3.1.

The main goal of our work is to determine a precise bound for the unary unbiased black-box complexity of OneMax, the problem of maximizing the function Om :

{0, 1} n → R, x → n i=1
x i , which assigns to each bit string the number of ones in it. That is, we aim at identifying a best-possible mutation-based algorithm for this problem.

The unary unbiased black-box complexity of OneMax is the smallest expected number of function evaluations that any algorithm following the structure of Algorithm 1 (cf. Section 2.1) exhibits on this problem. In the optimization process of Algorithm 1 a unary unbiased variation operator is asked for. In the context of optimizing pseudo-Boolean functions, a unary operator is an algorithm that is build upon a family (p(• | x)) x∈{0,1} n of probability distributions over {0, 1} n . Given some input

x it outputs a new string that it samples from the distribution p(• | x). A unary operator is unbiased if all members of its underlying family of probability distributions are symmetric with respect to the bit positions [n] := {1, . . . , n} and the bit values 0 and 1 (cf. [START_REF] Per | Black-Box Search by Unbiased Variation[END_REF] for a discussion). Unary unbiased variation operators are also referred to as mutation operators.

The following characterization of unary unbiased variation operators states that each such operator is uniquely defined via a probability distribution r p over the set [0..n] := {0} ∪ [n] describing how many bits (chosen uniformly at random without replacement) are flipped in the argument x to create a new search point y. Finding a best possible mutation-based algorithm is thus identical to identifying an optimal strategy to select the distribution r p . This characterization can also be derived from [Doe+13b, Proposition 19], although the original formulation of Proposition 19 in [START_REF] Doerr | Black-Box Complexities of Combinatorial Problems[END_REF] requires as search space [n] n-1 . Lemma 3.1. For every unary unbiased variation operator (p(•|x)) x∈{0,1} n there exists a probability distribution r p on [0..n] such that for all x, y ∈ {0, 1} n the probability p(y|x) that (p(•|x)) x∈{0,1} n samples y from x equals the probability of sampling a random number r from r p and then flipping r bits in x to create y. On the other hand, each distribution r p on [0..n] induces a unary unbiased variation operator.

To prove Lemma 3.1, we introduce the following notation.

Definition 3.2. Let r ∈ [0..n].
For every x ∈ {0, 1} n the operator flip r creates an offspring y from x by selecting r positions i 1 , . . . , i r in [n] uniformly at random (without replacement), setting y i := 1x i for i ∈ {i 1 , . . . , i r }, and copying

y i := x i for all other bit positions i ∈ [n] \ {i 1 , . . . , i r }.
With this notation, Lemma 3.1 states that every unary unbiased variation operator (p(•|x)) x∈{0,1} n can be described by Algorithm 5, for a suitably chosen probability distribution r p .

Since it will be needed several times in the remainder of this work, we briefly recall the following simple fact about the expected Om-value of an offspring generated by flip r .

Remark 3.3. Let x ∈ {0, 1} n and r ∈ [0..n]. The number of 1-bits that are flipped by the variation operator flip r follows a hypergeometric distribution with expectation equal to rOm(x)/n. The expected number of 0-bits that are flipped by the operator flip r equals r(n -Om(x))/n. The expected Om-value of an offspring generated from

x by applying flip r is thus equal to Om(x) -rOm(x)/n + r(n -Om(x))/n = (1 - 2r/n)Om(x) + r.
Algorithm 5 The unary unbiased operator r p samples for a given x an offspring by sampling from r p the number r of bits to flip and then applying flip r to x.

Choose an integer r ∈ [0..n] according to r p ; Sample y ← flip r (x);

To prove Lemma 3.1 we show the following. Lemma 3.4. For every unary unbiased variation operator (p(•|x)) x∈{0,1} n there exists a exists a probability distribution r p on [0..n] such that for all x, y ∈ {0,

1} n p (y|x) = r p (H(x, y))/ n H(x, y) , (3.1)
where here and henceforth H(x, y) denotes the Hamming distance of x and y.

Proof. Let p be a unary unbiased variation operator. We first show that for all x, y 1 , y 2 ∈ {0, 1} n with H(x, y 1 ) = H(x, y 2 ), the equality p(y 1 |x) = p(y 2 |x) holds. This shows that for any fixed Hamming distance d ∈ [n] and every string x, the probability distribution on the d-neighborhood

N d (x) := y ∈ {0, 1} n , H(x, y) = d of x is uniform.
Using the fact that the bit-wise XOR operator ⊕ preserves the Hamming distance, we obtain that for any y 1 , y 2 ∈ N d (x) it holds that

H(x ⊕ x, y 1 ⊕ x) = H(x ⊕ x, y 2 ⊕ x) = d. Since x ⊕ x = (0, . . . , 0), we thus observe that n i=1 (y 1 ⊕ x) i = n i=1 (y 2 ⊕ x) i = d.
This implies that there exists a permutation σ ∈ S n such that

σ(y 1 ⊕ x) = y 2 ⊕ x.
According to the definition of unary unbiased variation operators, p is invariant under "⊕" and "σ", yielding

p(y 1 |x) = p(y 1 ⊕ x|x ⊕ x) = p(σ(y 1 ⊕ x)|σ(x ⊕ x)) = p(y 2 ⊕ x|x ⊕ x) = p(y 2 |x).

This shows that p(•|x) is uniformly distributed on N d (x) for any d ∈ [n] and any

x ∈ {0, 1} n . For every x ∈ {0, 1} n and every d ∈ [n] let p (d,x) denote the probability of sampling a specific point at distance d from x. That is, for y 1 ∈ N d (x) we have p(y 1 |x) = p (d,x) . For x = x let y denote y 1 ⊕ (x ⊕ x ). Then by the unbiasedness of p we obtain that

H(y , x ) = H(y 1 , x) = d, and p (d,x ) = p(y |x ) = p(y ⊕ x ⊕ x | x ⊕ x ⊕ x ) = p(y 1 |x) = p (d,x) . Thus, for all x, x ∈ {0, 1} n it holds that p (d,x) = p (d,x ) =: p (d) .
For the unary unbiased variation operator p we can therefore define a distribution

r p on [0..n] by setting r p (d) = n d p (d) .
For all x, y ∈ {0, 1} n we obtain

p(y|x) = p (d,x) = p (d) = r p (d)/ n d ,
where we abbreviate d := H(x, y). This shows the desired equation (3.1).

Maximizing Drift is Near-Optimal

The goal of this section is to show that the algorithm which maximizes the expected progress over the best-so-far search point is optimal, apart from lower-order terms o(n), among all unary unbiased black-box algorithms. Consequently, its expected optimization time is essentially the unary unbiased black-box complexity.

The Drift Maximizing Algorithm

We regard as drift maximizing algorithm the algorithm summarized in Algorithm 6. We denote this algorithm by A * . A * starts by querying a uniform solution x ∈ {0, 1}. In each iteration of the main loop the algorithm generates a new solution y from x by flipping exactly R(Om(x)) bits in x, where R : [0..n] → [0..n] is a function that assigns to each fitness value the number of bits that should be flipped in a search point of this quality. We choose R such that the expected progress (drift) is maximized. When there is more than one value maximizing the drift, R chooses the smallest among these. That is,

R(Om(x)) := min arg max max{Om(flip r (x)) -Om(x), 0} | r ∈ [0..n] . (3.2) Algorithm 6 RLS for minimizing f : {0, 1} n → R Choose x uniformly at random from S = {0, 1} n . for t ← 1, 2, . . . do y ← flip R(Om(x)) (x) if Om(y) ≥ Om(x) then x ← y.
In this definition, we make use of the fact that the expected progress E max{Om(flip r (x)) -Om(x), 0} depends only on the fitness of x but not on its structure. This is due to the symmetry of the function Om. The offspring y replaces its parent x if and only if Om(y) ≥ Om(x).

Note here that the function R is deterministic, i.e., we only make use of a unary unbiased mutation operator which deterministically depends on the fitness of the current-best solution. Note further that the search point kept in the memory of algorithm A * is always a best-so-far solution. A * can be seen as an RLS-variant with fitness-dependent mutation strength.

Main Result and Proof Strategy

The main result of this entire section is the following statement, which says that the expected runtime of A * cannot be much worse than the unary unbiased black-box complexity of OneMax.

Theorem 3.5. Let A be a unary unbiased black-box algorithm. Denote by T (A) its runtime on OneMax and by

T (A * ) the runtime of A * . Then E(T (A)) ≥ E(T (A * )) - O(n 2/3 ln 9 (n)).
For the proof of Theorem 3.5 we derive in Section 3.2.3 a lower bound for the expected runtime of any unary unbiased algorithm, cf. Theorem 3.8. We then prove in Section 3.2.4 an upper bound for the expected runtime of A * , cf. Theorem 3.9. For both statements, we use the variable drift theorems presented in Section 2.4.

We therefore need to define suitable drift functions which bound from below the expected progress that can be made by algorithm A * and from above the maximal expected progress that any unary unbiased algorithm can make at every step of the optimization process. This is the purpose of the remainder of this subsection.

The Distance Function

Before we define the drift functions, we first note that in order to maximize the function Om, an optimal algorithm may choose to first minimize the function, and to then flip all bits at once to obtain the optimal Om-solution. Instead of regarding the maximization of the function Om, we therefore regard in the following the problem of minimizing the distance function d, which assigns to each string x the value d(x) := min{n -Om(x), Om(x)}. The black-box complexities of both problems are almost identical, as the following lemma shows.

Lemma 3.6. The unary unbiased black-box complexities of maximizing OneMax is at least as large as that of minimizing d and it is larger by at most one.

Proof. For the first statement, it suffices to observe that we can simulate the optimization of d when OneMax-values are available. The second statement follows from the already mentioned fact that once we have found a string x of distance value d(x) = 0, then either x or its bit-wise complement x has maximal OneMax-value.

Drift Expressions

For the definition of the drift functions used in the proofs of Theorems 3.8 and 3.9, we use the following notation. For a unary unbiased algorithm A we denote by (x(0), x(1), . . . , x(t)) the sequence of the first t + 1 search points evaluated by A. For every such sequence of search points, we abbreviate by

X t := min{d(x(i))|i ∈ [0..t]}
the quality of a best-so-far solution with respect to the distance function d. Note that for all t ≥ 0 it holds that X t ≥ X t+1 , i.e., the sequence (X t ) t≥0 is monotonically decreasing in t. For each k ∈ [0..n] let H(t, k) be the collection of all sequences (x(0), x(1), . . . , x(t)) of search points for which X t (x(0), x(1), . . . , x(t)) = k. Abusing notation, we write x ∈ ((x(0), x(1), . . . , x(t)))

when x = x(i) for some i ∈ [0..t].
Denoting by U the set of all unary unbiased operators acting on {0, 1} n , the maximal possible drift that can be achieved by a unary unbiased variation operator when the best-so-far distance is equal to k ∈ [0..n] is equal to

ĥ(k) := max {max {k -E(min{k, d(τ (x))}) | τ ∈ U, x ∈ H} | t ∈ N, H ∈ H(t, k)} . Using Lemma 3.1 it is not difficult to show that ĥ(k) = max {k -E(min{k, d(flip r (x))}) | r ∈ [0..n], x ∈ {0, 1} n with d(x) ≥ k} .(3.3)
To obtain a monotonically increasing function (as required by Theorem 2.7), we set

h(k) := max{ ĥ(i) | i ∈ [0..k]}. (3.4) Note that h(k) ≥ ĥ(k) for all k ∈ [0..n].
Chapter 3. Precise Unary Unbiased Black-box Complexity Finally, we set

h(k) := max {E(max{Om(flip r (x)) -Om(x), 0}) | x ∈ {0, 1} n with Om(x) = n -k, r ∈ [0..n]} , (3.5)
the maximal Om-drift that can be obtained from a search point whose Om-value is exactly equal to nk. We certainly have h(k) ≤ h(k) for all k ≤ n/2. However, we will show in Section 3.2.4 that for all values k ≤ n/2n 0.6 the difference between the functions h and h is small, showing that we can approximate the maximal drift h by mutating a best-so-far solution. This will be the key step in proving the upper bound for the expected runtime of algorithm A * . We also notice that h(k) ≥ max{Om( x) -

Om(x), 0} ≥ 2k -n. Therefore for any x ∈ {0, 1} n with Om(x) = n -k we have Om(x) + h(k) ≥ max{Om(x), Om( x)} ≥ n/2
, so that A * very quickly has a search point of function value Om(x) ≥ n/2. Informally, the interesting part of the runtime analysis for A * is therefore the fitness increase from a value around n/2 to n.

A Lower Bound for all Unary Unbiased Algorithms

Before proving the lower bound, we first introduce the following lemma arguing that the probability to make a large fitness gain is bounded by a small probability, as required by the condition to apply Theorem 2.7.

Lemma 3.7.

There exists an n 0 ∈ N such that, for all n ≥ n 0 , for all r ∈ [0..n], and for all x ∈ {0, 1} n , it holds that

Pr (d (flip r (x)) ≥ c (d(x))) ≥ 1 -n -4/3 ln 7 (n), (3.6)
where

c : [n] → [0..n], i → c(i) :=      i - √ n ln n for i ≥ n/6, i -ln 2 (n) for n 1/3 ≤ i < n/6, i -1 for i < n 1/3 .
Proof. Set p := n -4/3 ln 7 (n). To show (3.6), we first note that we can assume without loss of generality that Om(x) ≥ n/2. This is due to the symmetry of the distance function. In addition, we can assume that 0 < r ≤ n/2, because d(flip r (x)) and d(flip n-r (x)) are identically distributed. We make a case distinction according to the size of d := d(x). For all different cases we note that the event d(flip r (x)) < d happens in two cases, namely if

Om(flip r (x)) > Om(x) or if Om(flip r (x)) < n -Om(x).
We denote by Z the number of good flips in an application of flip r to x; i.e., the number of bits flipping from 0 to 1. Z follows a hypergeometric distribution and E(Z) = rd(x)/n, as discussed in Remark 3.3.

Case 1: d(x) ≥ n/6. We first regard the case that d := d(x) ≥ n/6. The Chernoff bound (e.g., the variants presented in Theorems 1.11 and 1.17 in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF]) applied to Z show that, for all λ > 0, Pr(Z

> E(Z) + λ) ≤ exp(-2λ 2 /n) and Pr(Z < E(Z) -λ) ≤ exp(-2λ 2 /n). Using that Om(flip r (x)) = Om(x) + 2Z -r and that n -Om(x) ≤ E(Om(flip r (x))) ≤ Om(x), we obtain that Pr (Om(flip r (x)) < n -Om(x) -2λ) ≤ Pr (Om(flip r (x)) < E(Om(flip r (x))) -2λ) = Pr (Om(x) + 2Z -r < Om(x) + E(2Z) -r -2λ) = Pr (2Z < E(2Z) -2λ) ≤ exp(-2λ 2 /n),
and that

Pr (Om(flip r (x)) > Om(x) + 2λ) ≤ Pr (Om(flip r (x)) > E(Om(flip r (x))) + 2λ) = Pr (2Z > E(2Z) + 2λ) ≤ exp(-2λ 2 /n).
From these two inequalities we conclude that

Pr(d(flip r (x)) < c(d(x)) = Pr(d(flip r (x)) < d - √ n ln n) ≤ 2 exp(-ln 2 (n)/2) < p for all d ≥ n/6.
Case 2: n 1/3 ≤ d(x) < n/6. By our assumptions r ≤ n/2 and Om(x) ≥ n/2 we obtain from Remark 3.

3 that E(Om(flip r (x))) = (1 -2r n )Om(x) + r ≥ (1 -2r n ) n 2 + r = n/2.
Using Chernoff bounds (e.g., Theorems 1.11 and 1.17 in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF]) we thus get Pr(Om(flip r (x)

) < n/6) ≤ exp(-2(n/2 -n/6) 2 /n) = o(p).
Consider the event Om(flip r (x)) ≥ Om(x) + ln 2 (n). It intrinsically requires that r ≥ ln 2 (n). We apply the Chernoff bound from Corollary 1.10 (b) in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF] to Z and obtain that

Pr (Om(flip r (x)) > Om(x)) = Pr Z > r 2 = Pr Z > n 2d E(Z) ≤ 2de n r/2 (3.7) ≤ e 3 r/2 = O(n -Ω(ln(n)) ) = o(p). Therefore Pr(d(flip r (x)) < c(d(x)) = Pr(d(flip r (x)) < d -ln 2 n) ≤ Pr(Om(flip r (x)) < n/6) + Pr (Om(flip r (x)) > Om(x)) = o(p)
for all n 1/3 ≤ d < n/6.

Case 3: d(x) < n 1/3 . We finally consider the case d < n 1/3 . Applying this condition to the first line of Equation (3.7), we obtain Pr(Om(flip r (x)) > Om(x)) ≤ Θ(n -4/3 ) = o(p) for all r ≥ 4. For r < 4 we consider the operators separately and observe that Pr (Om(flip

3 (x)) > Om(x)) = ( d 2 )( n-d 1 ) + ( d 3 ) ( n 3 ) = O(n -4/3 ) = o(p)
and

Pr (Om(flip 2 (x)) > Om(x)) = ( d 2 ) ( n 2 ) = O(n -4/3 ) = o(p).
Thus, altogether, we obtain that

Pr(d(flip r (x)) < c(d(x)) = Pr(d(flip r (x)) < d -1) ≤ Pr(Om(flip r (x)) < n/6) + Pr (Om(flip r (x)) > Om(x)) = o(p)
for all r ≥ 2 and d < n 1/3 . Needless to say that Pr(d(flip 1 (x)) < c(d(x)) = 0. This proves Equation (3.6).

Using Lemma 3.7 and Theorem 2.7, we are now ready to show the following lower bound.

Theorem 3.8. Let s := n/2n 0.6 . The expected runtime of any unary unbiased algorithm A on the OneMax problem satisfies

E (T A ) ≥ s x=1 1 h(x)
-Θ(n 2/3 ln 9 (n)).

Proof. For convenience, we assume that n is sufficiently large. Let A be a unary unbiased algorithm. We recall that by (x(0), x(1), . . . ) we denote the sequence of search points evaluated by A and by

X t = min{d(x(i)) | i ∈ [0.
.t]} the best-so-far distance after first t iterations of the main loop. Let

T := min{t ∈ N | X t = 0}. Then T ≤ T A := min{t ∈ N | Om(x(t)) = n}.
We prove a lower bound on T . Every unary unbiased black-box algorithm has to create its first search point uniformly at random. This initial search point x 0 has expected fitness E(Om(x 0 )) = n/2. By Chernoff's bound (we can use, for example, the variant presented in Theorem 1.11 in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF]) it furthermore holds that Pr(X 0 < s) = Pr(|Om(x 0 )n/2| > n 0.6 ) ≤ 2 exp(-2n 0.2 ). This probability is small enough such that even optimistically assuming T A = 0 whenever X 0 < s, the contribution of such events affect the lower bound by a term of O(n 2/3 ln 9 (n)). We can therefore safely assume that X 0 ≥ s.

For all i ∈ [n] let c(i) := min{ c(j) | j ≥ i},
where c is the function defined in Lemma 3.7. For all r ∈ [0..n], x ∈ {0, 1} n , and all distance levels

d ≤ d(x) it holds that c(d ) ≤ c(d(x)) and Pr (d(flip r (x)) > c(d )) ≥ Pr (d(flip r (x)) > c(d(x))) ≥ 1 -p.
By Lemma 3.1, this statement can be extended to arbitrary unary unbiased variation operators. Therefore, Pr (X t+1 > c(X t )) ≥ 1p for all t ∈ N.

We apply Theorem 2.7 to c and h. We first compute µ as in Theorem 2.7. By definition,

µ(i) = max{x | c(x) ≤ i} = max{x | min{ c(y) | y ≥ x} ≤ i} = max{x | c(x) ≤ i}, giving µ(i) :=          i + 1 for i < n 1/3 -ln 2 (n), i + ln 2 (n) for n 1/3 -ln 2 (n) ≤ i < n/6 - √ n ln n, i + √ n ln n for n/6 - √ n ln n ≤ i < n/2 - √ n ln n, n/2 for n/2 - √ n ln n ≤ i ≤ n/2.
According to Theorem 2.7, we can thus bound E(T | X 0 ) by

E (T | X 0 ) ≥ g(X 0 ) - g 2 (X 0 )p 1 + g(X 0 )p with g(x) = x-1 i=1 1 h(µ(x)) . Since h(µ(x)) ≥ h(µ(x)) ≥ E(max{Om(flip 1 (x)) -Om(x), 0} | x ∈ {0, 1} n with Om(x) = n -µ(x)) = µ(x)/n ≥ x/n, we obtain g(X 0 ) ≤ X 0 -1 i=1 n i = O(n ln(n)). Therefore g 2 (X 0 )p 1+g(X 0 )p = O(n 2/3 ln 9 (n)) for p = n -4/3 ln 7 (n).
Using the monotonicity of h and the fact that all summands are positive, we estimate g(X 0 ) by

X 0 -1 x=0 1 h(µ(x)) ≥ n 1/3 -ln 2 (n) x=1 1 h(x) + n/6- √ n ln n+ln 2 (n) x=n 1/3 1 h(x) + X 0 x=n/6 1 h(x) ≥ X 0 x=1 1 h(x) - ln 2 (n) h(n 1/3 -ln 2 (n)) - √ n ln n -ln 2 (n) h(n/6 - √ n ln n + ln 2 (n)) ≥ X 0 x=1 1 h(x) -Θ(n 2/3 ln 2 (n)).
Therefore we obtain

E(T A ) ≥ E(T | X 0 ≥ s) -O(n 2/3 ln 9 (n)) ≥ s x=1 1 h(x) - Θ(n 2/3 ln 9 (n)).

Upper Bound for the Drift Maximizer

The lower bound in Theorem 3.8 also holds for drift-maximizer A * described in the beginning of this section. We next show that A * achieves this runtime bound apart from the lower order term Θ(n 2/3 ln 9 (n)).

Theorem 3.9. Let s := n/2n 0.6 . The expected runtime of algorithm A * on One-Max satisfies

E (T A * ) ≤ s x=1 1 h(x)
+ Θ(n 0.6 ).

From the variable drift theorem, Theorem 2.4, we easily get s x=1 1 h(x) as upper bound for the expected runtime of A * . We therefore need to show that the difference between h(X t ) and h(X t ) is small. This is the purpose of the next subsection.

Maximizing Drift by Mutating a Best-So-Far Solution

As mentioned above, we show that the expected drift of any unary unbiased algorithm cannot be significantly better than that of A * . The main result of this subsection is the following lemma. Lemma 3.10. For sufficiently sufficiently large n and k ≤ n/2n 0.6 it holds that

0 ≤ h(k) -h(k) ≤ n exp(-Ω(n 0.2 )).
We start our proof of Lemma 3.10 by observing that the expected Om-value of the search point obtained from mutating and selecting the best of parent and offspring is strictly increasing with the quality of the parent. The proof is by induction. The base case is covered by the following lemma.

Lemma 3.11. Let x, y ∈ {0, 1} n with Om(y) = Om(x) + 1 ≥ n/2 and let r ∈ [0..n/2]. For all t ≥ 1 it holds that Pr (Om(flip r (x)) = Om(y) + t) ≤ Pr (Om(flip r-1 (y)) = Om(y) + t) .
(3.8)

Proof. We first notice that for t > r -1 both two probabilities are zero. We can therefore assume that 1 ≤ t ≤ r -1. Let d := n -Om(y), and let i be the number of zeros in y that flip r-1 flips from zero to one. Then there are r -1i ones that flip to zero. We thus have Om(flip r-1 (y)) = Om(y)

+ t if and only if i -(r -1 -i) = t; i.e.,
if and only if i = (t + r -1)/2. By the same reasoning Om(flip r (x)) = Om(y) + t if and only if i -(ri ) = t + 1 for i being the number of zeros flipped by flip r . This implies i = (r -1 + t)/2 = i + 1. We thus obtain

Pr (Om(flip r-1 (y)) = Om(y) + t) = ( d i )( n-d r-1-i ) ( n r-1 ) Pr (Om(flip r (x)) = Om(y) + t) = ( d+1 i+1 )( n-d-1 r-(i+1) ) ( n r )
To show equation (3.8), we abbreviate j := r -1i and use the facts that

( d+1 i+1 ) = ( d i ) d+1 i+1 , ( n-d j ) = ( n-d-1 j ) n-d n-d-j , and ( n i+j+1 ) = ( n i+j ) n-i-j i+j+1 to obtain that ( d+1 i+1 )( n-d-1 r-(i+1) ) ( n r ) ( d i )( n-d r-1-i ) ( n r-1 ) = (d + 1)(n -d -j)(1 + i + j) (i + 1)(n -d)(n -i -j) .
We aim to show the above ratio less or equal to 1. To this end, we compute the difference between the numerator and the denominator, and obtain

(d + 1)(n -d - j)(1 + i + j) -(i + 1)(n -d)(n -i -j) = (1 + i + j + d -n)(n + in -(1 + i + j)d) - j) = (r + d -n)(n + in -rd -j).
The first factor in this expression is negative, since both r ≤ n/2 and d ≤ n/2. The second factor is positive, because n > j, i > r/2 and d ≤ n/2 implying that inrd > (r/2)nr(n/2) ≥ 0.

We now regard the case that the same number r of bits are flipped in the two strings x and y. Lemma 3.12. Let x, y ∈ {0, 1} n with Om(y) = Om(x) + 1 and let r ∈ [0..n]. It holds that E (max{Om(flip r (x)) -Om(x), 0}) ≥ E (max{Om(flip r (y)) -Om(y), 0}) . (3.9)

Proof. Since permutation on bit-positions does not affect the analysis, we assume that x and y are of the following form.

x = 11 • • • 11 n 2 +δ 00 • • • 00 n 2 -δ-1 0 and y = 11 • • • 11 n 2 +δ 00 • • • 00 n 2 -δ-1 1.
(3.10)

For any r-sized subset S of [n] let x S (y S ) denote the offspring of x (y) in which the r positions in S are flipped. Then x S and y S differ only in the last bit and we have Om(x S ) -Om(y S ) ∈ {-1, 1} for all S. Therefore max{Om(flip r (x)), Om(x)} -max{Om(flip r (y)), Om(y)} ≥ -1 for all S Using that Om(y) -Om(x) = 1 we obtain

E (max{Om(flip r (x)) -Om(x), 0}) -E (max{Om(flip r (y)) -Om(y), 0}) = E (max{Om(flip r (x)), Om(x)} -Om(x)) -E (max{Om(flip r (y)), Om(y)} -Om(y)) = E (max{Om(flip r (x)), Om(x)} -max{Om(flip r (y)), Om(y)}) + 1 ≥ 0.
We now extend the last two lemmas to the case Om(y) -Om(x) > 1. Proof. To see the first statement, we first regard the case that r = 0. In this case, we have r ≤ Om(y) -Om(x), so that the probability that Om(flip r (x)) = Om(y) + t is zero for t > 0. For t = 0 the statement trivially holds, since the right-hand side of (3.11) is equal to one. For r > 0 the first statement follows from Lemma 3.11 and an induction over Om(y) -Om(x).

To prove the second statement we first assume that Om(y) -Om(x) = 1. Let r be the value that maximizes E (max{Om(flip r (y)) -Om(y), 0}). Using Lemma 3.12 we obtain

h(Om(y)) = E (max{Om(flip r (y)) -Om(y), 0}) ≤ E (max{Om(flip r (x)) -Om(x), 0}) ≤ h(Om(x)).
The general statement now follows by induction over Om(y) -Om(x).

We are now ready to prove the main result of this subsection, Lemma 3.10. Using this and the observations made in Remark 3.3, we easily see that

E(Om(flip r (x))) = Om(x) -r Om(x) n + r n-Om(x) n = Om(x)(1 -r/n) + (n -Om(x))r/n ≥ n/2.
This shows that E(Om(flip r (x)))n 0.6 ≥ n/2n 0.6 ≥ k. Together with a Chernoff bound applied to Om(flip r (x)) we thus obtain

Pr (Om(flip r (x)) < k) ≤ Pr Om(flip r (x)) < E(Om(flip r (x))) -n 0.6 = exp(-Ω(n 0.2 )). (3.12)
We first aim at bounding ĥ(k). To this end, we use the estimate 3.12 to obtain

E (k -min{k, d(flip r (x))}) = E (Om(flip r (x)) -(n -k) | Om(flip r (x)) > n -k) Pr (Om(flip r (x)) > n -k) + E (k -Om(flip r (x)) | Om(flip r (x)) < k) Pr (Om(flip r (x)) < k) ≤ E (max{Om(flip r (x)) -(n -k), 0}) + n exp(-Ω(n 0.2 )).
Let x be a search point with Om(x ) = nk, and let r = max{r -(d(x)d(x )), 0}.

According to Corollary 3.13 it holds for all i ∈ N that

Pr(Om(flip r (x)) = n -k + i) ≤ Pr(Om(flip r (x )) = n -k + i).
Using that E (max{Om(flip r (x))

-(n -k), 0}) = i≥1 i Pr(Om(flip r (x)) = n -k + i) we obtain E (k -min{k, d(flip r (x))}) ≤ E (max{Om(flip r (x )) -(n -k), 0}) + n exp(-Ω(n 0.2 )).
Referring to the definition of ĥ and h in equations (3.3) and (3.5), and using the symmetries mentioned in the beginning of this proof, we bound

ĥ(k) = max{k -E (min{k, d(flip r (x))}) | r ∈ [0..n], x ∈ {0, 1} n with d(x) ≥ k} = max{k -E (min{k, d(flip r (x))}) | r ∈ [0..n/2], x ∈ {0, 1} n with n/2 ≤ Om(x) ≤ n -k} ≤ max{E (max{Om(flip r (x )) -(n -k), 0}) | r ∈ [0..n/2], x ∈ {0, 1} n with Om(x ) = n -k} + n exp(-Ω(n 0.2 )) ≤ h(k) + n exp(-Ω(n 0.2 )).
According to the definition of h(k) in Equation (3.4), we obtain

h(k) = max{ ĥ(i) | i ∈ [0..k]} ≤ max{ h(i) | i ∈ [0..k]} + n exp(-Ω(n 0.2 ) = h(k) + n exp(-Ω(n 0.2 ),
where the last equality uses the monotonicity of h(k) with respect to k shown in Corollary 3.13.

As we will see in the next subsection, the n exp(-Ω(n 0.2 )) term in this bound accounts for an additive O(1) error in the runtime estimate only.

Proof of Theorem 3.9

With Lemma 3.10 at hand, we are now ready to prove Theorem 3.9.

Proof of Theorem 3.9. As mentioned above, we easily obtain from Theorem 2.4 that

E (T A * | x(0)) ≤ n-Om(x(0)) x=1 1 h(x) . (3.13)
According to Lemma 3.10 it holds that 0 < h(x) -h(x) ≤ n exp(-Ω(n 0.2 )) for

x ≤ n/2n 0.6 . Using again that flipping a single bit on a bit string with x zeros gives an expected progress in the Om-value of x/n, we recall that h

(x) ≥ h(x) ≥ x/n for all x ∈ [n/2]. Therefore, 1 h(x) - 1 h(x) = h(x) -h(x) h(x)h(x) ≤ n exp(-Ω(n 0.2 )) (x/n)(x/n) ≤ n 3 exp(-Ω(n 0.2 )) for all 1 ≤ x ≤ s.
Replacing h(x) by h(x) in inequality (3.13) and pessimistically assuming Om(x(0)) = 0 we thus obtain

E (T A * ) ≤ s x=1 1 h(x) + n 3 exp(-Ω(n 0.2 )) + n x=s 1 h(x) = s x=1 1 h(x) + n x=s 1 h(x) + O(1).
Using that h(x) ≥ x/n for all 0 < x ≤ n and h(x) ≥ 2xn for all n/2 < x ≤ n, we conclude

n x=s 1 h(x) ≤ n/2+n 0.6 x=s n x + n x=n/2+n 0.6 1 2x -n ≤ 2n 1.6 s + n/2 2n 0.6 = Θ(n 0.6 ).
Theorem 3.5 follows from Theorems 3.8 and 3.9 by observing that Θ(n 0.6 ) = o(n 2/3 ln 9 (n)).

Fitness-Dependent Mutation Strength

In the previous section we have seen that in order to compute the expected runtime of a best possible unary unbiased black-box algorithm for OneMax we can regard the algorithm A * that maximizes at any point in time the fitness drift. By Theorems 3.8 and 3.9 this algorithm cannot be worse (in expectation) than an optimal unary unbiased one by more than an additive Θ(n 2/3 ln 9 (n)) term.

In this section we give a relatively concise description of A * , i.e., we compute approximately the number of bits that need to be flipped in order to maximize the fitness drift. Since we are here talking about the drift in the fitness, it will be convenient to denote in this section by d(x) = n -Om(x) the fitness distance to the target. We also denote by

R opt (d, n) := min arg max E (max{Om(flip r (x)) -Om(x), 0}) | r ∈ [0..n], Om(x) = n -d , (3.14)
the number of bits that need to be flipped in a search point x ∈ {0, 1} n with

Om(x) = n -d such that the expected drift E(max{0, Om(flip Ropt(d,n) (x)) -Om(x)})
is maximized (breaking ties by flipping fewer bits).

The exact analysis of R opt is rather tedious, as we will demonstrate below. Luckily, it turns out that we can safely approximate this point-wise drift maximizing function

R opt (d, n) by some a function Ropt : [0, 1] → [0.
.n] which maps the relative fitness distance d(x)/n to a mutation strength. Since Ropt is much easier to work with, this is the focus of Section 3.3.2. For the approximation Ropt we make use of the fact that for values of r that are reasonably small compared to the problem dimension n and the current fitness distance d(x), the expected drift E(max{0, Om(flip

Ropt(d,n) (x)) - Om(x)}) is almost determined by the relative fitness distance d(x)/n. For very small d(x) = o(n) the fitness drift of flipping R opt (d/n) = 1 bit is exactly d(x)/n
, without any estimation error. We will also see in Section 3.3.1 that it suffice to regard constant values r.

Once the approximation of the function R opt by Ropt is established, we demonstrate in Section 3.3.3 a few properties of these two functions that will be useful in our subsequent computations; in particular for the numerical approximation of Ropt , which is carried out in Section 3.4.2. Most importantly, we shall see that Ropt is monotone, i.e., the number of bits to flip in order to maximize the approximated point-wise drift decreases with increasing fitness. We also show that both R opt and Ropt take only odd values, implying that flipping an even number of bits is suboptimal in all stages of the optimization process.

To ease the computation of Ropt , we analyze in detail the mutation rate for search points x(t) with fitness distance X t ≤ (1/2ε)n, where the constant ε satisfies 0 < ε < 1/2. Notice that by selecting between parent and its offspring at the end of each iteration in Algorithm 6 we have Om(x(t)) = n -X t . For the remaining fitness distances, we simply take Ropt (1/2ε) for all (1/2ε)n < X t ≤ n/2 and n for all X t > n/2. A detailed definition of Ropt,ε is provided in equation (3.19). We will prove in Theorem 3.28 that our adhoc definition of Ropt,ε (p) for p ≥ 1/2ε only causes an error term of O(εn) in the runtime.

The Exact Fitness Drift B(n, d, r)

In this subsection, we compute the exact fitness gain obtained from flipping r bits. We shall then argue that once we have a fitness of at least ( 1 2 + ε)n for some constant ε, the maximal fitness drift stems from flipping some constant number of bits.

Let x be a binary string of length n with fitness distance d, that is, with OneMaxvalue nd. By the symmetry of the OneMax function, the expected progress of flipping r bits in x does not depend on the structure of x but only on its fitness. We can therefore define the expected fitness gain from flipping r random bits in x by

B(n, d, r) := E (max{0, d -d(flip r (x))} | Om(x) = n -d) .
To compute B(n, d, r) arithmetically, let us assume that i ∈ [0..r] is the number of bits flipped from 0 to 1. Then ri bits have flipped in the opposite direction from 1 to 0, resulting in a progress of i -(ri). This progress is positive if and only if i > ri, i.e., if and only if i > r/2. The probability for i bits flipping in the "good" direction is

( d i )( n-d r-i )/( n r ). We therefore obtain B(n, d, r) = r i= r/2 ( d i )( n-d r-i ) (2i -r) ( n r )
.

We show that the maximal fitness drift is obtained from flipping a constant number of bits once we have a fitness of at least ( 1 2 + ε)n. The main argument is that flipping a single random bit already gives a better expected fitness gain than flipping many bits, which is due to the fact that when flipping many bits, the strong concentration of the hypergeometric distributions renders it highly unlikely that a fitness gain is obtained at all.

Lemma 3.14. Let 0 < ε < 1/2 and α := 2 log(4/(ε 2 (1/2 -ε)). Then for all n ∈ N, d ≤ (1/2 -ε)n, and all r ≥ 2α/ε 2 , we have B(n, d, r) < B(n, d, 1)/2.
Proof. Let Z denote the number of "good" flips (i.e., the number of bits flipping from 0 to 1). As discussed in Remark 3.3, the random variable Z follows a hypergeometric distribution with mean value E(Z) = dr/n = pr < r/2, where we abbreviate p := d/n. Applying the Chernoff bound presented in Theorem 1.9 (b) in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF] to Z, we obtain

Pr (Z > r/2) = Pr (Z > E(Z)/(2p)) ≤ e 1/(2p)-1 (1/(2p)) 1/(2p) E(Z) = (2p) 1/(2p) e 1/(2p)-1 rp = (2pe) 1/(2p) e rp = 2pe e 2p r/2 . (3.15) We then regard B(n, d, r)/(B, n, d, 1) ≤ r Pr(Z > r/2)/(d/n) = (r/p) 2pe e 2p
r/2 = r(2e) r/2 p r/2-1 e -pr . We notice that for fixed r ≥ 2α/ε 2 and 0 < p < 1/2ε, (p r/2-1 e -pr ) = (r/2 -1)p r/2-2 e -prrp r/2-1 e -pr = p r/2-2 e -pr (r/2 -1rp)

≥ p r/2-2 e -pr (2α/ε -1) > 0,
thus it remains to check the statement for d = (1/2ε)n. Using the Taylor expansion e 2δ = 1

+ 2δ + 2δ 2 + (4/3)δ 3 + O(δ 4 ) < 1 + 2δ + 3δ 2 we see that lim p→1/2-ε 2pe/e 2p = lim δ→ε 2(1/2 -δ)e/e 2(1/2-δ) = lim δ→ε (1 -2δ)e 2δ < lim δ→ε (1 -2δ)(1 + 2δ + 3δ 2 ) = 1 -ε 2 -6ε 3 < 1 -ε 2 . Therefore we obtain B(n, d, r) ≤ r Pr(Z > r/2) ≤ r(2pe/e 2p ) r/2 < r(1 -ε 2 ) r/2 . Using the fact that (1 -ε 2 ) 1/ε 2 < 1/e, r ≥ 2α/ε 2 > 2/ε 2 , and r(1 -ε 2 ) r/2 monotonically de- creases when r > 2/ε 2 , we obtain B(n, d, r) < r exp(-α) ≤ 2α exp(-α)/ε 2 . Since log(α exp(-α)) = log(α) -α < -α/2, then B(n, d, r) < 2α exp(-α)/ε 2 < 2 exp(-α/2)/ε 2 = (2/ε 2 )(ε 2 (1/2 -ε)/4) = (1/2 -ε)/2 = B(n, d, 1)/2 for d = (1/2 -ε)n.

Approximating

B(n, d, r) via A(r, d n , 1 -d n )
When n and d are large compared to r, the expected progress B(n, d, r) is almost determined by d/n. This inspires the following definition of A(r, p, q) which will have the property that

A(r, d n , 1 -d n ) is a good approximation of B(n, d, r
). The definition for general p and q instead of p and q = 1p will be useful in the following proofs. Definition 3.15. For all r ∈ N, p ∈ [0, 1], and q ∈ [0, 1], let A(r, p, q) := r i= r/2 r i (2ir)p i q r-i .

(3.16)

The following Theorem 3.16 makes precise how well for p = d/n and q = 1p the value A(r, p, q) approximates the expected progress B(n, d, r). Theorem 3.16. Let 0 < ε < 1/2 and α = 2 log(4/(ε 2 (1/2ε)) (as in Lemma 3.14). Then for all n ∈ N large enough, all r < 2α/ε 2 , and all 2r

≤ d ≤ (1/2 -ε)n, we have A r, d n , n -d n -B(n, d, r) < 3r 3 d . (3.17)
The first step in the proof of Theorem 3.16 is the following statement, which compares suitable A-values with B-values. Note that here we profit from the general definition of A(r, p, q) instead of the special case A(r, p, 1p). Lemma 3.17. Consider n ∈ N large enough and

1 ≤ r ≤ d ≤ (1/2 -ε)n with 0 < ε < 1/2. It holds that A r, d n , n -d n -r ≥ B(n, d, r) ≥ A r, d -r n , n -d -r n . (3.18)
Proof. For any two positive integers r and i ≤ r we abbreviate (r

) i := r(r -1) . . . (r -i + 1) = i-1 j=0 (r -j).
With this notation, we can express B(n, m, r) as

B(n, d, r) = r i= r/2 ( d i )( n-d r-i ) (2i -r) ( n r ) = r i= r/2 (d) i (n -d) r-i (n) r r i (2i -r) .
From the elementary fact that for all r/2 ≤ i ≤ r, we have (n

-d) r-i ≤ (n -d) r-i and (n) r ≥ (n) i (n -r) r-i , we obtain (d) i (n -d) r-i (n) r ≤ (d) i (n -d) r-i (n) i (n -r) r-i ≤ d n i n -d n -r r-i . This shows B(n, d, r) ≤ A r, d n , n-d n-r .
To show the second inequality, we use the fact that for all i ≤ r ≤ n, we have

(n) r ≤ n r , (d) i ≥ (d -r) i , and (n -d) r-i ≥ (n -d -r) r-i . Consequently, (d) i (n -d) r-i (n) r ≥ (d -r) i (n -d -r) r-i n r = d -r n i n -d -r n r-i , yielding B(n, d, r) ≥ A r, d-r n , n-d-r n .
With Lemma 3.17 at hand, we now prove Theorem 3.16.

Proof of Theorem 3.16. According to the definition of A(r, p, q) in (3.16) we have

∂A(r, p, q) ∂q = r i= r/2 (r -i) r i (2i -r)p i q r-i-1 < r 2 r i= r/2 r i (2i -r)p i q r-i-1 = rA(r, p, q) 2q < r 2 2q ,
where we have used in the last step that A(r, p, q) ≤ r.

Using that n-d n > 1/2 and 0 < n-d n-r -n-d n = n-d n-r • r n < (1 + o(1)) r n , we bound A r, d n , n -d n -r -A r, d n , n -d n ≤ r 2 2(1/2) n -d n -r - n -d n ≤ (1 + o(1))r 3 n .
Similarly we have

∂A(r, p, q) ∂p = r i= r/2 i r i (2i -r)p i-1 q r-i < r r i= r/2 r i (2i -r)p i-1 q r-i = rA(r, p, q) p < r 2 p . Using d ≥ 2r we obtain A r, d n , n -d -r n -A r, d -r n , n -d -r n ≤ r 2 (d -r)/n • r n = r 3 d -r > 2r 3 d . Therefore A r, d n , n -d n -r -A r, d -r n , n -d -r n = (1 + o(1))r 3 n + 2r 3 d < 3r 3 d .
By Lemma 3.17, it suffices to estimate

|A(r, d n , n-d n ) -B(n, d, r)| < A(r, d n , n-d n-r ) - A(r, d-r n , n-d-r n ) < 3r 3 d .

Approximate Optimal Number of Bits to Flip

The goal of this section is to approximate the function R opt which tells us how many bits one should flip in order to maximize the point-wise drift. Given Theorem 3.16 above, it is tempting to assume that the map p → arg max r∈N A(r, p, 1p) should do. Analogous to Lemma 3.14 we show in the following lemma that it suffices to regard constant r for the approximated drift.

Lemma 3.18. Let 0 < ε < 1/2 and α := 2 log(4/(ε 2 (1/2 -ε)). For all n ∈ N with d ≤ (1/2 -ε)n and all r ≥ 2α/ε 2 , the expected approximated drift A(r, d n , n-d n ) < A(1, d n , n-d n )/2. Proof. Consider the binomial random variable Z ∼ Bin(r, d/n). Let p = d/n then E(Z) = pr.
Applying the Chernoff bound presented in Theorem 1.9 (b) in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF] to Z, we obtain

Pr (Z > r/2) = Pr (Z > E(Z)/(2p)) ≤ e 1/(2p)-1 (1/(2p)) 1/(2p) E(Z) = 2pe e 2p r/2
, which is the same inequality as (3.15) in Lemma 3.14. Since A(r, p,

1 -p) := r i= r/2 ( r i )(2i -r)p i (1 -p) r-i ≤ r r i=0 1 2i>r ( r i )p i (1 -p) r-i = r Pr(Z > r/2) and A(1, p, 1 -p) = p,
apply the samle analysis as in Lemma 3.14, the statement holds.

In the remainder of this section we show that flipping a number r of bits that maximizes A(r, d/n, 1d/n) yields indeed a good approximation of the best possible expected progress. Since in principle there could be more than one r maximizing A(r, p, 1p) for a given relative distance p ∈ (0, 1/2), we break ties by preferring smaller values of r. For p ≥ 1/2ε, where our reasoning above was not applicable, we do not try to find an optimal number of bits to flip, but rather one that does the job of giving a near-optimal runtime. Since a random initial search point has a fitness close to n/2, not too much time is spent in this regime anyway. Consequently, we define, for all ε > 0,

Ropt,ε (p) :=        min arg max r∈N A(r, p, 1 -p) for 0 < p ≤ 1/2 -ε, Ropt (1/2 -ε) for 1/2 -ε < p ≤ 1/2, n for p > 1/2, (3.19)
According to Lemma 3.18 the function Ropt,ε is well defined (for all ε > 0).

We prove two important properties of the functions Ropt,ε , which are summarized in the following theorem. The proof of the second claim in Theorem 3.19 will be carried out in Section 3.3.3. It is purely combinatorial. The proof of the monotonicity of Ropt,ε , in contrast, is surprisingly technical. It will be carried out in Section 3.3.3.

R opt and Ropt Attain Only Odd Values

One possibly surprising property of the functions R opt and Ropt,ε is that they take only odd values. That is, regardless of how far we are from the optimum, the maximal drift is obtained for an odd number of bit flips. The following two lemmas show this statement for the approximate and the exact drift, respectively. Lemma 3.20 (flipping even numbers of bits is sub-optimal, statement for the approximated drift A). For all k ∈ N and p ∈ (0, 1) it holds that A(2k,p,1-p) 2k = A(2k+1,p,1-p) 2k+1 . Consequently Ropt,ε (d/n) takes odd values for all d ≤ n/2 and all ε > 0.

Proof. By definition of the function A in (3.16) and using the facts that for all r ∈ N and all i ≤ r we have

r i = r r -i , r i i = r r -1 i -1 , and r i (r -i) = r r -1 i ,
we easily see that

A(r, p, q) = r i= r/2 r i (2i -r)p i q r-i = r i= r/2 r i i - r i (r -i) p i q r-i = r r i= r/2 r -1 i -1 - r -1 i p i q r-i . (3.20)
This shows that, for all k ∈ N,

A(2k + 1, p, q) 2k + 1 = 2k+1 i=k+1 2k i -1 - 2k i p i q 2k+1-i = 2k+1 i=k+1 2k -1 i -1 - 2k -1 i + 2k -1 i -2 - 2k -1 i -1 p i q 2k+1-i = 2k i=k+1 2k -1 i -1 - 2k -1 i p i q 2k+1-i + 2k+1 i=k+1 2k -1 i -2 - 2k -1 i -1 p i q 2k+1-i = 2k i=k+1 2k -1 i -1 - 2k -1 i p i q 2k+1-i + 2k i=k 2k -1 i -1 - 2k -1 i p i+1 q 2k-i = 2k i=k 2k -1 i -1 - 2k -1 i p i q 2k+1-i + p i+1 q 2k-i - 2k -1 k -1 - 2k -1 k p k q k+1 = 2k i=k 2k -1 i -1 - 2k -1 i p i q 2k-i = A(2k, p, q) 2k ,
where we have used in the last step that p + q = 1 and ( 2k-1 k-1 ) = ( 2k-1 k ). Lemma 3.20 is not an artifact of the approximation of the drift by function A but also holds for the exact drift-maximizing function B. This lemma will not be needed in the following, but we believe it to be interesting in its own right. The reader only interested in the proof of the main results of this work can skip this proof. Lemma 3.21 (flipping even numbers of bits is sub-optimal, statement for exact drift B). For all n, d, k

∈ N satisfying 0 < d ≤ n 2 and 0 < 2k + 1 ≤ n, it holds that B(n, d, 2k) < B(n, d, 2k + 1). Moreover, B(n,d,2k) 2k = B(n,d,2k+1) 2k+1 holds.
Proof. Using again the shorthand (r) i := r(r -1) • • • (ri + 1) for all positive integers r and i ≤ r, we get

B(n, d, 2k + 1) = 1 ( n 2k+1 ) 2k+1 i=k+1 d i n -d 2k -i + 1 (2i -2k -1) = 1 ( n 2k+1 ) k i=0 d i + k + 1 n -d k -i (2i + 1) = (n -2k -1)! n! k i=0 2k + 1 k -i (d) i+k+1 (n -d) k-i (2i + 1).
Similarly, we obtain

B(n, d, 2k) = 1 ( n 2k ) 2k i=k+1 d i n -d 2k -i (2i -2k) = 1 ( n 2k ) k-1 i=0 d i + k + 1 n -d k -i -1 (2i + 2) = (n -2k)! n! k-1 i=0 2k k -i -1 (d) i+k+1 (n -d) k-i-1 (2i + 2).
Therefore, the ratio of B(n, d, 2k) and B(n, d, 2k + 1) is

B(n, d, 2k) B(n, d, 2k + 1) = (n -2k) k-1 i=0 ( 2k k-i-1 )(d) i+k+1 (n -d) k-i-1 (2i + 2) k i=0 ( 2k+1 k-i )(d) i+k+1 (n -d) k-i (2i + 1) = (n -2k) k-1 i=0 ( 2k k-i-1 )(d -k -1) i (n -d) k-i-1 (2i + 2) k i=0 ( 2k+1 k-i )(d -k -1) i (n -d) k-i (2i + 1) . Replacing (d -k) with u and (n -d) with v gives B(n, d, 2k) B(n, d, 2k + 1) = (u + v -k) k-1 i=0 ( 2k k-i-1 )(u -1) i (v) k-i-1 (2i + 2) k i=0 ( 2k+1 k-i )(u -1) i (v) k-i (2i + 1)
.

Using the shorthand λ j i for the coefficient of r j in the polynomial (r) i , we now take a close look at the denominator, which is a polynomial in u and v. It is not difficult to see that for all a, b ∈ N ∪ {0}, the coefficient of the term u a v b in the denominator equals

ψ(a, b) = k i=0 2k + 1 k -i λ a+1 i+1 λ b k-i (2i + 1), while the coefficient of term u a v b in numerator equals φ(a, b) = k-1 i=0 2k k -i -1 λ a i+1 λ b k-i-1 + λ a+1 i+1 λ b-1 k-i-1 -kλ a+1 i+1 λ b k-i-1 (2i + 2). Since (r) i+1 = (r -i)(r) i , it is easily verified that λ j i -iλ j+1 i = λ j+1 i+1 . (3.21)
We use (3.21) to simplify φ(a, b) in the following way.

φ(a, b) = k-1 i=0 2k k -i -1 λ a+1 i+2 λ b k-i-1 + λ a+1 i+1 λ b k-i (2i + 2) = k i=0 2k k -i -1 (2i + 2) + 2k k -i (2i) λ a+1 i+1 λ b k-i = k i=0 (2i + 2) + k + i + 1 k -i (2i) 2k k -i -1 λ a+1 i+1 λ b k-i = k i=0 2k(2i + 1) k -i 2k k -i -1 λ a+1 i+1 λ b k-i = 2k 2k + 1 k i=0 2k + 1 k -i λ a+1 i+1 λ b k-i (2i + 1) = 2k 2k + 1 ψ(a, b).
The above holds for all 0 ≤ a, b ≤ k, showing that indeed

B(n, d, 2k) B(n, d, 2k + 1) = 2k 2k + 1 .

Monotonicity of Ropt,ε

We now argue that, for all ε > 0, the function Ropt,ε is monotone. It seems quite intuitive that the optimal number of bit flips should decrease with decreasing distance to the optimum, and this has been previously observed empirically, e.g., in [START_REF] Bäck | Self-adaptation in genetic algorithms[END_REF][START_REF] Fialho | Extreme Value Based Adaptive Operator Selection[END_REF][START_REF] Fialho | Dynamic Multi-Armed Bandits and Extreme Value-Based Rewards for Adaptive Operator Selection in Evolutionary Algorithms[END_REF]. However, formally proving the desired monotonic relationship requires substantial technical work. We note that, as a side result, Lemma 3.26 shows that for search points having a distance of less than n/3 to the optimum (or its complement), the maximal approximated fitness gain is obtained by 1-bit flips.

Lemma 3.22 (and definition of cut-off points). For any two integers

0 ≤ k 1 < k 2 , the functions p → A(2k 1 + 1, p, 1 -p) and p → A(2k 2 + 1, p, 1 -p) intersect exactly once in the interval (0, 1/2]. Denoting this intersection p 0 and letting A 0 := A(2k 1 + 1, p 0 , 1 -p 0 ), we call (p 0 , A 0 ) the cut-off point of A(2k 1 + 1, p, 1 -p) and A(2k 2 + 1, p, 1 -p).
We have

A(2k 1 + 1, p, 1 -p) > A(2k 2 + 1, p, 1 -p) if and only if 0 < p < p 0 .
The graph in Figure 3.1 illustrates the functions p → A(k, p, 1p) for k = 1, 3, 5, 7. The precise cut-off points will be computed numerically in Section 3.4.2.

In order to prove Lemma 3.22, we first show the following combinatorial lemma.

Lemma 3.23. For all k, r ∈ N ∪ {0} and 0 ≤ q ≤ 1 it holds that Proof. We prove the equation by induction. It is obvious that equation (3.22) holds for all r ≥ 0 and k = 0. Assume that it holds for some pair of integers (k, r + 1), then the following computation shows that it also holds for (k + 1, r).

k i=0 k + r + 1 i (1 -q) k-i q i = k i=0 i + r r q i . (3.22)
k+1 i=0 k + 1 + r + 1 i (1 -q) k-i+1 q i = k + r + 2 k + 1 q k+1 + (1 -q) k i=0 k + (r + 1) + 1 i (1 -q) k-i q i = k + r + 2 r + 1 q k+1 + (1 -q) k i=0 i + r + 1 r + 1 q i = k+1 i=0 i + r r q i .
For arbitrary combinations of k and r, we thus get the desired correctness of (3.22) for the pair (k, r) inductively from that of the pair (0, r + k).

We use Lemma 3.23 to compute the second derivative of A(r, p, q) for q in Lemma 3.24 and then obtain the second derivative of A(r, p, q) for p in Lemma 3.25. We first notice that A(1, p, 1p) = p and dA(1, p, 1p)/dp = 1. Thus we only look at the second derivative for r > 1.

Lemma 3.24. For all k ∈ N and all 0 < p ≤ 1/2, it holds that

d 2 A(2k + 1, p, 1 -p) (d(1 -p)) 2 = c k p k-1 (1 -p) k-1 , (3.23)
where c k is a constant related to k via

c k := 2(2k -1)(2k + 1) 2k -2 k -1 = 4k + 2 β(k, k) ,
and β(x, y) := 1 0 t x-1 (1t) y-1 dt = Γ(x)Γ(y) Γ(x+y) is the well-known beta function.

Proof. Set q := 1p. We expand A(2k + 1, p, q) according to Equation (3.20) and use Lemma 3.23 to obtain the following

A(2k + 1, p, q) = (2k + 1) 2k i=k 2k i - 2k i + 1 p i+1 q 2k-i = (2k + 1) k i=0 2k k + i - 2k k + i + 1 p k+i+1 q k-i = (2k + 1)p k+1 • k i=0 2k i - 2k i -1 p k-i q i = (2k + 1)p k+1 k i=0 k + (k -1) + 1 i p k-i q i + q k-1 i=0 (k -1) + k + 1 i p k-1-i q i = (2k + 1)p k+1 k i=0 i + (k -1) i q i + q k-1 i=0 i + k i q i = (2k + 1)p k+1 • k i=0 k + i -1 i - k + i -1 i -1 q i .
We extract the term p k+1 in the above equation and define the polynomial

f k (q) := ∞ i=0 a i k q i with coefficient a i k = 0 when i > k and a i k := k + i -1 i - k + i -1 i -1 = k + i -1 i k -i k when i ≤ k. (3.24)
Then A(2k + 1, p, q) = (2k + 1)p k+1 f k (q). We use the general Leibniz rule for the second derivative (informally, this rule states that (f g) = f g + 2f g + f g ) and obtain

d 2 A(2k + 1, p, q) d 2 q = (2k + 1)p k-1 • p 2 f k (q) -2(k + 1)pf k (q) + (k + 1)kf k (q) .
It remains to prove that

p 2 f k (q) -2(k + 1)pf k (q) + (k + 1)kf k (q) = 2(2k -1) 2k -2 k -1 q k-1 . (3.25)
We look at the coefficient of q i in the left part of equation (3.25) and we denote it by c i k . By expanding f k (q) into a polynomial and replacing p by 1q, we see that c i k equals the coefficient of q i in the following expression

(1 -q) 2 (a i k q i + a i+1 k q i+1 + a i+2 k q i+2 ) -2(k + 1)(1 -q)(a i k q i + a i+1 k q i+1 ) +(k + 1)k(a i k q i ). This shows that c i k is equal to a i k ((k + 1)k + 2(k + 1)i + i(i -1)) + a i+1 k (-2(k + 1)(i + 1) -2(i + 1)i) + a i+2 k ((i + 2)(i + 1)) .
According to (3.24) the coefficient a i k satisfies

a i+1 k = a i k + a i+1 k-1 , and (3.26) a i+1 k-1 = a i k • k i + 1 • k -i -2 k -i , for k > i. (3.27)
We use Equation (3.26) to rewrite the expression of c i k for i ≤ k -2, and then use Equation (3.27) to simplify the equation in the following way

c i k = a i k (k(k -1)) + a i+1 k-1 (-2(k -1)(i + 1)) + a i+2 k-2 ((i + 2)(i + 1)) = a i k k(k -1) -2a i k k(k -1) k -i -2 k -i + a i k k(k -1) k -i -4 k -i = 0.
Noticing that a k k = 0 shows that f k (q) has a degree of k -1. This implies that the term q k-1 has the highest degree in (3.25). Its coefficient is

c k-1 k = a k-1 k ((k + 1)k + 2(k + 1)(k -1) + (k -1)(k -2)) = 2(2k -1) 2k -2 k -1 .
This proves the claimed equality in (3.23).

Lemma 3.25. For all k ∈ N and all 0 < p ≤ 1/2, it holds that

d 2 A(2k + 1, p, 1 -p) dp 2 = c k p k-1 (1 -p) k-1 , dA(2k + 1, p, 1 -p) dp = c k p 0 x k-1 (1 -x) k-1 dx and A(2k + 1, p, 1 -p) = c k p 0 y 0 x k-1 (1 -x) k-1 dxdy.
Furthermore for all k ∈ N 0 we can write

A(2k + 1, p, 1 -p) = p 0 dA(2k + 1, x, 1 -x) dp dx.
Proof. The first equality can be easily obtained from the equality in (3.23). Consequently,

dA(2k + 1, p, q) dp = c k p 0 x k-1 (1 -x) k-1 dx + C 1 with C 1 ∈ R, A(2k + 1, p, q) = c k p 0 y 0 x k-1 (1 -x) k-1 dxdy + C 1 p + C 2 with C 2 ∈ R.
Using the fact that lim p→0 A(2k

+ 1, p, q) = o(p) for k ≥ 1, we obtain C 1 = C 2 = 0 as claimed.
For the last statement, we only need to consider the case k = 0. Recalling that A(1, p, 1p) = p and dA(1, p, 1p)/dp = 1 shows that the equality also applies to this case.

We next prove Lemma 3.22.

Proof of Lemma 3.22. Using the notation from Lemma 3.24, we first notice that for all k > 0 we have

c k+1 c k = 2(2k + 1)(2k + 3)( 2k k ) 2(2k -1)(2k + 1)( 2k-2 k-1 ) = 4k + 6 k > 4. (3.28) Let 0 < k 1 < k 2 .
By the above, we have 4

< (4 + 6/k 2 ) k 2 -k 1 < c k 2 /c k 1 < (4 + 6/k 1 ) k 2 -k 1 . Notice that c k 1 (pq) k 1 -1 -c k 2 (pq) k 2 -1 = (pq) k 1 -1 (c k 1 -c k 2 (pq) k 2 -k 1 ).
We now use the fact that lim p→0 pq = 0 and lim p→1/2 pq = 1/4 to obtain that for all

k 2 > k 1 > 0, lim p→0 (c k 1 -c k 2 (pq) k 2 -k 1 ) > 0 while lim p→1/2 c k 1 -c k 2 (pq) k 2 -k 1 < 0.
This shows that the function

p → c k 1 (pq) k 1 -1 intersects with p → c k 2 (pq) k 2 -1 in at most one point p I ∈ (0, 1/2). Moreover, we have that c k 1 (pq) k 1 -1 ≥ c k 2 (pq) k 2 -1 if and only if p ∈ [0, p I ]. Therefore, when p > 0, the function p → p 0 c k 1 (x -x 2 ) k 1 -1 dx intersects with the function p → p 0 c k 2 (x -x 2 ) k 2
-1 dx at most once for p ∈ (0, 1/2). We now prove that the intersection exists.

Notice that for all k > 1 we have

c k 0.5 0 (x -x 2 ) k-1 dx = c k 2 1 0 (x -x 2 ) k-1 dx = c k 2 β(k, k) = 2k + 1,
and thus

lim p→1/2 p 0 c k 1 (x -x 2 ) k 1 -1 dx - p 0 c k 2 (x -x 2 ) k 2 -1 dx = 2(k 1 -k 2 ) < 0, while p 0 c k 1 (x -x 2 ) k 1 -1 dx > p 0 c k 2 (x -x 2 ) k 2 -1 dx for all p ∈ (0, p I ).
There exists a intersection point p II ∈ (0, 1/2) such that

p 0 c k 1 (x -x 2 ) k 1 -1 dx ≥ p 0 c k 2 (x -x 2 ) k 2 -1 dx if and only if p ∈ [0, p II ].
This shows that for all k 2 > k 1 > 0 there exists a point p II ∈ (0, 1/2) such that

dA(2k 1 + 1, p, q) dp ≥ dA(2k 2 + 1, p, q) dp if and only if p ∈ [0, p II ]. (3.29)
To extend the conclusion to

k 1 = 0, let k 2 > k 1 = 0. We have lim p→1/2 p 0 c k 2 (x - x 2 ) k 2 -1 dx = 2k 2 + 1 and lim p→0 p 0 c k 2 (x -x 2 ) k 2 -1 dx = 0, while dA(1, p, q)/dp = 1.
Therefore the intersection point p II still exists and there is a unique such point.

As a result we see that the function p 0 dA(2k 1 + 1, x, 1x) intersects with the function p 0 dA(2k 2 + 1, x, 1x) at most once for p ∈ (0, 1/2) and

p 0 dA(2k 1 + 1, x, q) > p 0 dA(2k 2 + 1, x, q) for all p ∈ (0, p II ) while lim p→1/2 (A(2k 1 + 1, p, q) -A(2k 2 + 1, p, q)) < 0.
This shows that A(2k 1 + 1, p, q) intersects with A(2k 2 + 1, p, q) exactly once at some value p III < 1/2.

We are now ready to prove the monotonicity of Ropt,ε .

Proof of the first part of Theorem 3.19. Let ε > 0, let p 0 ∈ (0, 1), and set q 0 := 1p 0 . By Lemma 3.20 it holds that A(2k, p 0 , q 0 ) < A(2k + 1, p 0 , q 0 ). This shows that Ropt,ε (p 0 ) is odd. Let k ∈ N ∪ {0} such that Ropt,ε (p 0 ) = 2k + 1. By definition of Ropt,ε (cf. equation (3.19)), k is the smallest integer obtaining a drift of A(2k + 1, p 0 , q 0 ). For all integers k < k we thus obtain A(2k + 1, p 0 , q 0 ) > A(2k + 1, p 0 , q 0 ).

(3.30) By Lemma 3.22 we also get that for all p > p 0 it holds that

A(2k + 1, p, q) > A(2k + 1, p, q). (3.31)
Therefore Ropt,ε (p) ≥ 2k + 1 for all p > p 0 . Since the statement holds for all p 0 ∈ (0, 1/2ε] we obtain the monotonicity of Ropt,ε .

Ropt,ε (p) = 1 when 0 < p < 1/3 and R opt (d, n) = 1 when 0 < d = o(n)
We first show that flipping one bit is optimal for the approximated drift when the distance to the optimal solution is less than n/3. Lemma 3.26. For all ε > 0 and all 0 < p < 1/3 it holds that Ropt,ε (p) = 1.

Proof. Let ε > 0. Due to the monotonicity of Ropt,ε , it suffices to show that Ropt,ε (1/3) = 1. By Lemma 3.20 we only need to consider odd values of r. According to Lemma 3.25 if the second derivative

c k x k-1 (1 -x) k-1 > c k+1 x k (1 -x) k for all
x ∈ (0, 1/3) then A(2k -1, 1/3, 2/3) > A(2k + 1, 1/3, 2/3) and thus Ropt,ε = 2k + 1. We notice that

c k+1 x k (1 -x) k c k x k-1 (1 -x) k-1 = 4k + 6 k x(1 -x) ≤ 4k + 6 k • 2 9 for all 0 < x < 1 3 .
For all k > 12 it holds that (4k + 6)/k < 9/2, which implies that

c k x k-1 (1 -x) k-1 > c k+1 x k (1 -x) k .
We therefore obtain that Ropt,ε (1/3) ≤ 25. For the remaining values, i.e., for r = 1, 3, . . . , 25, we can compute A(r, 1/3, 2/3) numerically. This numerical evaluation shows that the maximum value 1/3 is obtained (only) by r = 1 and r = 3. This proves Ropt,ε (1/3) = 1.

We show in Lemma 3.27 that flipping one bit is also optimal for the exact fitness drift when the distance is a lower-order term of n.

Lemma 3.27. For all 0 < d = o(n) it holds that R opt (d, n) = 1.
Proof. Since d < n/4, Lemma 3.14 yields with ε := 1/4 that R opt (d, n) < 4 4 log(4). Referring to Lemma 3.17, we obtain for all 3 ≤ r ≤ 4 4 log(4) that B(n, d, r) <

A(r, d/n, 1) = Θ((d/n) (r+1)/2 ) = o(d/n). Since R opt attains only odd values, we obtain R opt (d, n) = 1 for all 0 < d = o(n).

Runtime Loss From Using the Approximated Drift

We show in this section that the expected runtimes of the exact and the approximate drift maximizer do not differ substantially. More precisely, we show that also the approximate drift maximizer also obtains an expected runtime on OneMax that is very close to that of an optimal unary unbiased black-box algorithm, cf. Corollary 3.29. To make things precise, we denote for every ε > 0 by à * ε the algorithm which we obtain from Algorithm 6 by replacing the mutation rate R(Om(x)) by Ropt,ε (1 -Om(x)/n).

To state the main result, for all ε > 0, for all n ∈ N, and all 0 < p ≤ 1/2ε we abbreviate

A max,ε (p) := A( Ropt,ε (p), p, 1 -p) and B max (p, n) := B(n, pn , R opt ( pn , n)).
(3.32) We notice from Lemma 3.14 and Lemma 3.18 that Ropt,ε (1/2ε) = Θ(1) and

R opt ( (1/2 -ε)n , n) = Θ(1)
. Considering the drift of single bit flip, we see that

A max,ε (1/2 -ε) ≥ 1/2 -ε. According to the definition of h in equation (3.5), we have B max (d/n, n) = h(d) ≥ d/n for all 0 < d ≤ (1/2 -ε)n.
Theorem 3.28. For all constant 0 < ε < 1/2 the expected runtime of algorithm à *

ε on OneMax satisfies E T Ã * ε ≤ (1/2-ε)n x=1 1 h(x) + εn A max,ε (1/2 -ε) + o(n).
Moreover,

E T Ã * ε ≤ (1/2-ε)n x=1 1 A max,ε (x/n) + εn A max,ε (1/2 -ε) + o(n).
Proof. Let constant 0 < ε < 1/2. It is easily seen from Theorem 2.4 and from the definition of Ropt,ε in (3. 19) that

E T Ã * ε | x(0) ≤ n-Om(x(0)) x=1 1 B(n, x, Ropt,ε (x/n)) ≤ n/2 x=1 1 B(n, x, Ropt,ε (x/n)) + 1.
To ease representation, let r A (x) := Ropt,ε (x/n) and r B (x

) := R opt (x, n) for all 0 < x ≤ (1/2 -ε)n.
According to Theorem 3.16 we have

A r A (x), x n , 1 - x n -B (n, x, r A (x)) = O(1/x) and A r B (x), x n , 1 - x n -B(n, x, r B (x)) = O(1/x). Since A(r B (x), x/n, 1 -x/n) ≤ A(r A (x), x/n, (n -x)/n) = A max,ε (x/n) and B(n, x, r A (x)) ≤ B(n, x, r B (x)) = B max (x/n, n) = h(x)
, we obtain from Theorem 3.16 that, for all 0

< x < (1/2 -ε)n, B(n, x, r A (x)) -h(x) = O(1/x) and |A max,ε (x/n) -B(n, x, r A (x))| = O(1/x),
where we use the fact that r A (x) = Θ(1) according to Lemma 3.18. Referring to Lemma 3.26 and Lemma 3.27, we have r Notice that h(x) ≥ B(n, x, 1) = x/n for all x > 0. Using the fact that 0 < h(x)h(x) ≤ n exp(-Ω(n 0.2 )) for 0 < x < n/2n 0.6 in Lemma 3.10, we obtain 1

B (x) = r A (x) = 1 when 0 < x = o(n). Therefore, A max,ε (x/n) = B(n, x, r A (x)) = h(x) for all 0 < x = o(n).
B(n, x, r A (x)) - 1 h(x) = |h(x) -B(n, x, r A (x))| B(n, x, r A (x))h(x) ≤ o(1/n) for 0 < x ≤ n 0.99 , O((1/x)/(x/n) 2 ) for n 0.99 < x ≤ (1/2 -ε)n. .
Referring to Lemma 3.12 and the definition of B(n, x, r) we see that, for all fixed n and r, the fitness drift B(n, x, r) monotonically increases with respect to

x. Therefore, for all x > (1/2ε)n, we have r

A (x) = r A ((1/2 -ε)n) and B(n, x, r A (x)) ≥ B(n, (1/2 -ε)n, r A ((1/2 -ε)n)) ≥ A max,ε (1/2 -ε) -O(1/n) ≥ 1/2 -ε -O(1/n) = Ω(1), thus E(T Ã * ε ) ≤ (1/2-ε)n x=1 1 h(x) + O(1) + O(n 0.03 ) + εn A max,ε (1/2 -ε) + o(n).
This proves the first statement.

The second statement can be shown by using similar methods to bound the ab-

solute difference |1/B(n, x, r A (x)) -1/A max,ε (x/n)| for 0 < x ≤ n/2.
Corollary 3.29. For all constant 0 < ε < 1/2 the difference between the expected runtime of à * ε on OneMax and that of an optimal unary unbiased black-box algorithm is O(εn). Furthermore, the absolute difference between the expected runtimes of A * and à * ε is also O(εn).

Proof. Let constant 0 < ε < 1/2 and let A be an arbitrary unary unbiased black-box algorithm. By Theorems 3.8 and 3.28 it holds that

E (T A ) ≥ n/2-n 0.6 x=1 1 h(x) -Θ(n 2/3 ln 9 (n)) ≥ (1/2-ε)n x=1 1 h(x) -o(n) ≥ E T Ã * ε -O(εn).
The second statement is a direct consequence of the first and Theorem 3.5.

Runtime Analysis for the Approximate Drift-Maximizer à * ε

We compute in this section the expected time needed by Algorithm à * ε to optimize OneMax. We fix 0 < ε < 1/2. As proven in Lemma 3.26 algorithm à * ε flips Ropt,ε (p) = 1 bit whenever 0 < p < 1/3. In this regime à * ε is thus equal to RLS. It is well known (and easy to prove by a simple fitness-level argument) that the expected time needed by RLS starting in a search point of OneMax value 2n/3 to reach the all-ones string equals n n/3 i=1 1/i = nH n/3 = n(ln(n/3) + γ) + 3/2 + O(1/n), where γ ≈ 0.57721 . . . denotes again the Euler-Mascheroni constant. It therefore remains to compute the time needed by à * ε to reach for the first time a search point having fitness at least 2n/3. Formally, we also need to show that the first search point having fitness at least 2n/3 does not have a fitness value that is much larger than this. Since we flip a constant number of bits only, we get this statement for free. Note also that it is shown below that in the interval before reaching this fitness level the algorithm flips only 3 bits. Apart from this situation around fitness layer 2n/3 we do not have to take care of jumping several fitness layers by hand, but this is taken into account already in the drift theorems from which we derive our runtime estimates.

Drift Analysis

As we did in Section 3.2, we employ the variable drift theorems, Theorems 2.4 and 2.7, to compute upper and lower bounds for the expected runtime of algorithm à * ε . We will provide a numerical evaluation of these expressions in Section 3.4.2. Lower bound. We first compute a lower bound for the expected runtime E(T A ) of any unary unbiased black-box algorithm A on OneMax. According to Theorem 3.8 and using a similar method to estimate

|1/A max,ε (x/n) -1/h(x)| = o(1) as in Theorem 3.28 for 0 < x ≤ (1/2 -ε)n, we obtain that E (T A ) ≥ n/2-n 0.6 x=1 1 h(x) -Θ(n 2/3 ln 9 (n)) ≥ (1/2-ε)n x=1 1 A max (x/n) -o(n) = nH n/3 + (1/2-ε)n x= n/3 1 A max (x/n) -o(n).
Let k ∈ N and let 1/2ε =:

p 0 > p 1 > . . . > p k > 1/3. Using the fact that A max,ε is increasing, we bound E(T A ) by E (T A ) ≥ n ln n 3 + γ + k i=1 p i-1 -p i A max,ε (p i-1 ) + p k 1/3 dp A max,ε (p) -o(n). (3.33)
Upper bound. Using the fact that Ropt,ε (x/n) = 1 for all 0 < x ≤ n/3 and referring to Theorem 3.28, we obtain

E T Ã * ε ≤ nH n/3 + (1/2-ε)n x= n/3 1 A max,ε (x/n) + εn A max,ε (1/2 -ε) + o(n).
Using the same partition points as in the lower bound statement and the monotonicity of A max,ε , we have

E(T Ã * ε ) ≤ n ln n 3 + γ + k i=1 p i-1 -p i A max,ε (p i ) + 1/2 -p 0 A max,ε (p 0 ) + p k 1/3 dp A max,ε (p) + o(n).
(3.34)

Numerical Evaluation of the Expected Runtime

In this section we evaluate expressions (3.33) and (3.34) numerically to compute an estimate for the expected runtime of algorithm à * ε on OneMax and for the unary unbiased black-box complexity. Theorem 3.30. For sufficiently small ε > 0 the expected runtime

E(T à * ε ) of algo- rithm à * ε on OneMax is n ln(n) -cn ± o(n)
for a constant c between 0.2539 and 0.2665. This bound is also the unary unbiased black-box complexity of OneMax.

We can rewrite the expression in Theorem 3.30 to n (ln (n/3) + γ + c ) + o(n) for a constant c between 0.2549 and 0.2675 to ease a comparison with the expected runtime of the previously best known unary unbiased algorithm, which is the one presented in [START_REF] De Perthuis De Laillevault | Money for Nothing: Speeding Up Evolutionary Algorithms Through Better Initialization[END_REF]. This latter algorithm has an expected runtime equaling that of RLS up to an additive term of order o(n). It is hence n(ln(n/2) + γ) ± o(n). For sufficiently small ε > 0 Algorithm à * ε is thus by an additive (ln(3) -ln(2)c )n ± o(n) term faster, on average, than RLS or the algorithm presented and analyzed in [START_REF] De Perthuis De Laillevault | Money for Nothing: Speeding Up Evolutionary Algorithms Through Better Initialization[END_REF]. That is, compared to RLS, algorithm à * ε saves between 0.138n ± o(n) and 0.151n ± o(n) iterations on average.

To compute E(T Ã * ε ), we split the interval (0, 1 2 ) into intervals (L 2i+1 , R 2i+1 ], i = 0, 1, . . ., such that for each i and each p ∈ (L 2i+1 , R 2i+1 ] the number Ropt,ε (p) of bits that need to be flipped in order to maximize the approximated expected fitness increase A(•, p, 1p) is 2i + 1 (note that this is independent of ε, since ε just determines the cut-off point after which only use a bound for the drift-maximizing number of bit flips). Table 3.1 displays the first few intervals along with the corresponding drift values at the borders of the interval. We observe that the further we are away from the optimum (this corresponds to larger r by Theorem 3.19), the smaller the size of the interval.

The bound for the expected runtime of algorithm à * ε reported in Theorem 3.30 is obtained by setting p 0 = R 4001 , p k = R 9 and using the following partition points

p 0 = R 4001 > R 3001 > R 2001 > R 1001 > R 951 > R 901 > R 851 > • • • > R 200 > R 151 > R 101 > R 35 > R 34 > • • • > R 10 > R 9 = p k .
The accuracy of our approximation can be increased by adding denser partition points, especially to the smaller side near p k .

Fixed-Budget Analysis

In this section, we compare the algorithms developed in this work with the classic RLS heuristic (which was the essentially best previous unary unbiased algorithm for Om) in the fixed-budget perspective, that is, we compare the expected fitnesses obtained after a fixed budget B of iterations. This performance measure was introduced by Jansen and Zarges [START_REF] Jansen | Performance analysis of randomised search heuristics operating with a fixed budget[END_REF] to reflect the fact that the most common use of search heuristics is not to compute an optimal solution, but only a solution of reasonable quality. We note that the time to reach a particular solution quality, called T A,f (a) in [START_REF] Doerr | A method to derive fixed budget results from expected optimisation times[END_REF] where this notion was first explicitly defined, would be an alternative way to phrase such results. We do not regard this performance measure here, but we would expect that, in a similar vein in as the following analysis, also in this measure our algorithm is superior to RLS by a (small) constant percentage.

Our main result in this section is that our drift maximizer with a fixed budget compute solutions having a roughly 13% smaller fitness distance to the optimum. This result contrasts the lower-order advantage in terms of the expected runtime, i.e., the average time needed to find an optimal solution.

The main challenge is proving the innocent statement that the time taken by our algorithm to find a solution x of fitness Om(x) ≥ 2n/3 is strongly concentrated. Such difficulties occur often in fixed-budget analyses, see, e.g. [START_REF] Doerr | A method to derive fixed budget results from expected optimisation times[END_REF]. We prove the desired concentration via the following well-known martingale version of Azuma's inequality [START_REF] Azuma | Weighted sums of certain dependent variables[END_REF] (as opposed to the simpler method of bounded differences, which appears not to be applicable here).

Theorem 3.31 (Method of Bounded Martingale Differences). Let X 1 , X 2 , . . . , X n be an arbitrary sequence of random variables and let f be a function satisfying the property that for each i ∈ [n], there is a non-negative

c i such that | E(f | X 0 , X 1 , . . . , X i-1 ) -E(f | X 0 , X 1 , . . . , X i )| ≤ c i . Then Pr (|f -E(f )| ≥ δ) ≤ 2 exp - δ 2 2 n i=1 c 2 i for all δ > 0.
Consider a run of the algorithm à * ε with small constant 0 < ε < 1/6. Let X t := n -max{Om(x(i)) | i ∈ [0..t]} be the current smallest fitness distance and let r max := Ropt,ε (1/2ε) be the maximal mutation strength. Let T 1/3 be the first time at which the distance to the optimum is at most n/3, i.e., T 1/3 is the smallest t for which X t ≤ n/3. Let N := 3r max n and define the function f by setting f (X 0 , X 1 , . . . ) := min{N, T 1/3 }.

We notice that Pr(T 1/3 > f ) = Pr(T 1/3 > N ) = Pr(X N > n/3). Referring to Lemma 3.16, we obtain for all 1). Using the fact that X t -X t+1 ≤ r max , we obtain Pr(X t > X t+1 | X t > n/3) ≥ 1/(3r max )o(1). Define binary random variables Y t by setting Y t := 1 Xt>X t+1 , if X t > n/3, and otherwise by having Y t = 1 with probability 1/(3r max )o(1) independently for all such Y t . Note that, by definition, we have Pr[Y t = 1] ≥ 1/(3r max )o(1) regardless of the outcomes of Y t , t < t. Consequently, by well-known results, e.g., Lemma 3 in [START_REF] Doerr | Better Runtime Guarantees via Stochastic Domination[END_REF], the Y t admit the same Chernoff bounds for the lower tail as independent binary random variables with success probability 1/(3r max )o(1). We thus estimate Pr

X t > n/3 that E(X t -X t+1 | X t ) = B(n, X t , Ropt (X t /n)) ≥ A max,ε (X t /n) -O(1/X t ) ≥ 1/3 -o(
(X N > n/3) ≤ Pr(Y 1 + Y 2 + • • • + Y N < (2/3)n) = exp(-Ω(n)). Consequently E(T 1/3 -f ) < E(T ) Pr(T 1/3 > f ) = exp(-Ω(n)).
Using the fact that X t -X t+1 ≤ r max , the additive drift theorem yields that the expected influence of one iteration on the remaining optimization time is at most

r max /(1/3 -o(1)) < 4r max . Consequently, for 1 ≤ i ≤ N , we have | E(f | X 0 , X 1 , • • • , X i-1 ) -E(f | X 0 , X 1 , • • • , X i )| ≤ 4r max .
Applying Theorem 3.31 and using the fact that Pr(T 1/3 > f ) = exp(-Ω(n)) and

E(T 1/3 -f ) = exp(-Ω(n)), we compute Pr |T 1/3 -E(T 1/3 )| ≥ n 0.6 ≤ Pr |f -E(T 1/3 )| ≥ n 0.6 + exp(-Ω(n)) ≤ Pr |f -E(f ) -E(T 1/3 -f )| ≥ n 0.6 + exp(-Ω(n)) ≤ Pr |f -E(f )| ≥ n 0.6 -E(T 1/3 -f ) + exp(-Ω(n)) ≤ Pr |f -E(f )| ≥ n 0.6 /2 + exp(-Ω(n)) ≤ 2 exp - n 1.2 /4 2N (4r max ) 2 + exp(-Ω(n)) = o(exp(-n 0.1 )).
According to the computation in the proof of Theorem 3.30 and using the fact that E(T 1/3 ) = E(T Ã * ε ) -nH n/3 , we obtain with probability 1 -O(exp(-n 0.1 )) that 0.2549n ≤ T 1/3 ≤ 0.2675n.

Consider a budget of B = kn iterations with k ≥ 0.2675. Let s := 0.2675n . With probability 1 -O(exp(-n -0.1 )), a run of algorithm à * ε has X s ≤ n/3. Conditional on this, in the remainder à * ε mutates exactly one bit in each iteration according to Lemma 3.26. Since E(X t | X t-1 ) = X t-1 (1 -1/n) in this case, we have for all

t ≥ s that E(X t | X s ) = E(X s ) (1 -1/n) t-s ≤ (n/3)(1 -1/n) t-s . Therefore, with a budget of B ≥ 0.2675n algorithm à * ε reaches a fitness distance X B satisfying E(X B ) ≤ E(X B | X s ≤ n/3) + n • Pr(X s > n/3) ≤ (1 + o(1))(n/3)(1 -1/n) B-0.2675n .
Using the same reasoning for RLS, we compute for Y B the fitness distance RLS reaches with the same budget of B that

E(Y B ) = (n/2)(1 -1/n) B = (3/2)(1 -1/n) 0.2675n (n/3)(1 -1/n) B-0.2675n ≥ (1 -o(1))(3/2) exp(-0.2675) E(X B ) = (1 -o(1))1.1479... E(X B ).
In other words, E(X B ) ≤ (1 + o(1))0.8711... E(X A ), that is, with the same budget, Algorithm à * ε is roughly 13% closer to the optimum than RLS.

Self-adjusting Mutation Rate

While it is clear that choosing the best mutation strength for each fitness level can improve the performance, it is not so clear how to find a good mutation strength function efficiently. To overcome this difficulty, we propose to choose the mutation strength in each iteration based on the experience in the optimization process so far. We enforce gaining a certain experience by designating each iteration with probability δ as learning iteration. In a learning iteration, we flip a random number of bits (chosen uniformly at random from a domain [1..r max ]) and store (in an efficient manner) the progress made in these iterations. In all regular iterations, we use the experience made in these learning iterations to determine the most promising mutation strength and create the offspring with this mutation strength.

More precisely, let us denote by x t the search point after the t-th iteration, that is, after the mutation and selection step of iteration t. Denote by x 0 the random initial search point. If t is a learning iteration, denote by r t the random mutation strength r used in this iteration. Otherwise set r t = 0.

The main idea of our algorithm is to learn the efficiency of the mutation strengths, that is, the expected progress made when flipping r bits, for all r ∈ [1..r max ]. We do so via a time-discounted average of the progresses observed in the learning iterations: We define the estimated progress, called velocity in the absence of a better name, after the t-th iteration by

v t [r] := t s=1 1 rs=r (1 -ε) t-s (f (x s ) -f (x s-1 )) t s=1 1 rs=r (1 -ε) t-s . (3.35)
In this expression, the parameter ε, called forgetting rate, determines the decrease of the importance of older information. Since (1ε) 1/ε ≈ 1/e, the reciprocal of the forgetting rate is (apart from constant factors) the information half-life.

We first observe that we can compute the velocities iteratively and thus, unlike equation (3.35) might suggest, do not need to store the full history of the learning iterations. To this aim, we need to store one additional value for each r, namely the sum of the (1ε) t-s terms used in the weighted average, that is,

w t [r] := t s=1 1 rs=r (1 -ε) t-s .
Then the following recursive description of the velocities and weight sums is easily seen: If in iteration t + 1 we have not done a learning step with mutation strength r, that is,

r t+1 = r, then v t+1 [r] = v t [r] and w t+1 [r] = (1 -ε)w t [r]. If r t+1 = r, then v t+1 [r] = (1 -ε)w t [r]v t [r] + f (x t+1 ) -f (x t ) (1 -ε)w t [r] + 1 , w t+1 [r] = (1 -ε)w t [r] + 1.
For exploiting the experience gained in the learning iterations, we adopt a greedy strategy and always choose the mutation strength with highest velocity (breaking ties randomly, but giving preference to the previous-best mutation strength). Our greedy choice of the mutation strength might be detrimental for fitness landscapes in which the optimal mutation strength changes very frequently. Therefore a velocity-weighted random choice might be more fruitful.

From this discussion, we derive the algorithm randomized local search with selfadjusting mutation strength (Algorithm 7).

Mathematical Runtime Analysis on OneMax

In this section, we analyze via mathematical means how self-adjusting algorithm optimizes the OneMax function. This is an asymptotic analysis in terms of the problem size n. We refer to the previous well-established runtime analysis literature for more details on the motivations of mathematical runtime analysis and on the meaning of asymptotic results.

(X d ) - E(X d-H ) = O(H/n). Also, X d stochastically dominates X d-H .
The following lemma states that, apart from an initial segment of the optimization process, the values of w t [r] can essentially assumed to be constant over time.

Lemma 3.34. Let r ∈ [1..r max ], t ≥ H := (1/ε) ln(n) and w * := δ/r max ε. Then with probability 1 -exp(-n Ω(1) ),

|w t [r] -w * | ≤ w * O(n -0.002 ).
Proof. By definition, we have w t [r] = t s=1 1 rs=r (1ε) t-s . The random variables 1 rs=r are independent Bernoulli trials with success probability δ/r max . Consequently,

E(w t [r]) = (δ/r max ) t s=1 (1 -ε) t-s = (δ/r max ) 1 -(1 -ε) t+1 1 -(1 -ε) ,
which is smaller than δ/r max ε and greater than (δ/r max ε)

(1 -(1 -ε) H ) ≥ (δ/r max ε)(1 -n -1
), the latter using t ≥ H and the well-known estimate (1ε) ≤ exp(-ε) valid for all ε ∈ R.

By the multiplicative Chernoff bound in Theorem 2.8, taking γ = n -0.002 , we have Pr

[|w t [r] -E(w t [r])| ≥ γ(δ/r max ε)] ≤ 2 exp(-γ 2 (1 -1/n) 2 (δ/r max ε)/3) = exp(-Ω(n 0.006 )).
The following two lemmas show how well our learning mechanism is able to detect the currently most profitable mutation strength.

Lemma 3.35. Let r ∈ [1..r max ], t ≥ 1 and H = (1/ε)2 ln(n).
Then with probability at least 1 -exp(-n Ω(1) ), we have

v t+H [r] ≤ (1 + O(n -0.002 )) max{E(X r f (x t+H ) ), (ε/δ)n 0.01 }. Proof. Let S := t+H s=1 1 rs=r (1 -ε) t+H-s (f (x s ) -f (x s-1 )). Since f (x s ) -f (x s-1 ) ≤ r ≤ r max , we have S 0 := t s=1 1 rs=r (1 -ε) t+H-s (f (x s ) -f (x s-1 )) ≤ t s=1 (1 - ε) t+H-s r max ≤ r max (1/ε)(1 -ε) H ≤ r max /εn 2 .
For the rest

S 1 = t+H s=t+1 1 rs=r (1 -ε) t+H-s (f (x s ) -f (x s-1
)) of the sum S, we argue as follows.

Independent of what happened before iteration s, by Lemma 3.33 the progress f (x s )f (x s-1 ) is dominated by a random variable with distribution X d (xt) . By Lemma 1.20 in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF], S 1 is dominated by S = t+H s=t+1 1 rs=r (1ε) t+H-s Y s , where the Y s are independent copies of the random variable X d(xt) .

We have

E(S ) = t+H s=t+1 (δ/r max )(1 - ε) t+H-s E(X d(xt) ) ≤ (δ/r max ε)E(X d(xt) ) ≤ (δ/r max ε) max{E(X d(xt) ), (ε/δ)n 0.01 } ≤ (1 + O(H/n))(δ/r max ε) max{E(X d(x t+H )
), (ε/δ)n 0.01 } =: U , where the changing x t into x t+H for an extra (1 + O(H/n)) factor is justified by Lemma 3.33 (note that

d(x t+H ) ≥ d(x t ) -E(X d(xt) )O(H) ≥ d(x t ) -O(d(x t )/n)O(H) with
high probability is justified by Lemma 3.32). The multiplicative Chernoff bound, recall (i) that these bounds remain valid when the expectation is replaced by an upper bound for the expectation and (ii) that our independent summands take values in [0, r max ], gives that Pr[S ≥ (1 + γ)U ] ≤ exp(-γ 2 U /3r 2 max ) = exp(-Ω(γ 2 n 0.01 )), which is exp(-Ω(n 0.006 )) for γ = n -0.002 .

Consequently, with probability at least 1 -exp(-Ω(n 0.006 )), we have S = S 0 +

S 1 ≤ r max /εn 2 + (1 + O(n -0.002 ))(δ/r max ε) max{E(X f (x t+H ) ), (ε/δ)n 0.01 } = (1 + O(n -0.002 ))(δ/r max ε) max{E(X f (x t+H )
), (ε/δ)n 0.01 }. By Lemma 3.34, we have w t+H [r] = (1 -O(n -0.002 ))δ/r max ε with probability at least 1 -exp(-n Ω(1) ). Consequently, with probability at least 1 -exp(-n Ω(1) ), we have

v t+H [r] = S/w t+H [r] ≤ (1 + O(n -0.002 )) max{E(X f (x t+H ) ), (ε/δ)n 0.01 }. Lemma 3.36. Let r ∈ [1..r max ], t ≥ 1 and H = (1/ε) ln(n). Assume that E(X r d(x t+H ) ) = Ω(n 0.01 ε/δ).
Then with probability at least 1 -exp(-n Ω(1) ), we have

v t+H [r] ≥ (1 -O(n -0.002 ))E(X r f (x t+H ) ). Proof. Let S := t+H s=1 1 rs=r (1 -ε) t+H-s (f (x s ) -f (x s-1 )). This dominates S 1 = t+H s=t+1 1 rs=r (1 -ε) t+H-s (f (x s ) -f (x s-1 )).
Independent of what happened in iterations before iteration s, the progress in the s-th iteration f (x s )f (x s-1 ) dominates

X d(x t+H ) . Let S := t+H s=t+1 1 rs=r (1 -ε) t+H-s Y s
, where the Y s are independent random variables with distribution X d(x t+H ) . By Lemma 1.20 of [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF], S dominates S .

By construction, S is a sum of independent random variables each taking values in [0, r max ]. Estimating the geometric series as in Lemma 3.34, we compute

E(S ) = t+H s=t+1 (δ/r max )(1 -ε) t+H-s E(X d(x t+H ) ) ≥ (1 -1/n)(δ/r max ε)E(X d(x t+H ) ) =: L.
The multiplicative Chernoff bound gives Pr(S ≤ (1γ)L) ≤ exp(-γ 2 L/2r 2 max ), which is exp(-n Ω(1) ) for γ = n -0.002 and using E(X d(x t+H ) ) = Ω(n 0.01 ε/δ). Consequently, with probability 1 -exp(-n Ω(1) ), we have S ≥ (1 -O(n -0.002 ))(δ/r max ε)E(X d(x t+H ) ).

Since by Lemma 3.34, we have w t+H [r] = (1 + O(n -0.002 ))δ/r max ε with probability at least 1 -exp(-n Ω(1) ), we conclude that with probability at least 1exp(-n Ω(1) ), we have

v t+H [r] = S/w t+H [r] ≥ (1 + O(n -0.002 ))E(X f (x t+H ) ).
The fact that our algorithm very precisely detects the optimal mutation strength implies that its fitness progress in each iteration is very close to the maximum possible (Theorem 3.37) and that it has a performance very close to the algorithm developed in Section 3.3 (Theorem 3.38).

Theorem 3.37. Let T be the optimization time of our algorithm with parameters δ = n -0.01 and ε = n -0.99 on the OneMax function. Let T = min{T, 2n ln(n)}.

Then with probability at least

1 -O(n 0.19 ), for each non-learning iteration t ∈ [2 ln(n)/ε, T ], we have E(X r * t d(x t-1 ) ) ≥ (1 -O(n -0.002 )) max{E(X r d(x t-1 ) ) | r ∈ [1..r max ]}.
Proof. Assume that none of the polynomially many exceptional events in Lemmas 3.34, 3.35, and 3.36 (occurring each with probability at most exp(-n Ω(1) )) appears in the first T iterations. Let t be such that d(x t-1 ) ≥ n 0.04 . Then E(X 1 d(x t-1 ) ) = d(x t-1 )/n ≥ n -0.96 > n -0.97 = n 0.01 ε/δ. Consequently, by Lemma 3.35 and 3.36 and the fact that

r * t ∈ argmax r v t-1 [r], we have E(X r * t d(x t-1 ) ) ≥ (1 -O(n -0.002 )) max{E(X r d(x t-1 ) ) | r ∈ [1..r max ]}.
We now exploit that more-bit flips have a very small chance to be accepted towards the end of the process. More precisely, for r ≥ 2 we have Pr(X r d ) = O((d/n) 2 ) with the asymptotics for d/n → 0. Consequently, the probability that in some iteration with d(x t ) ≤ n 0.3 a progress is made with a more-bit flip is O(T n -1.4 ) = Õ(n -0.4 ). Let us condition on this event. Then, also by the previous paragraph, the optimization process from a fitness distance of n 0.3 to n 0.04 equal the process of the classic randomized local search heuristic (doing one-bit flips) prolonged by unsuccessful multi-bit flips at a rate of Θ(δ). Consequently, via the standard arguments of the analysis of randomized local search on OneMax (which essentially is the coupon collector process), we see that with probability 1 -exp(-n Ω(1) ), it takes more than 0.25n ln(n) iterations to reduce the fitness distance from n 0.3 to n 0.04 .

We estimate, for each r ≥ 2, the value of v t [r] after the first iteration t with d(x t ) = n 0.04 . Since the previous t = 0.25n ln n iterations did not see any successful rbit flip, we have

S = t s=1 1 rs=r (1 -ε) t-s (f (x s ) -f (x s-1 )) ≤ t-t s=1 (1 -ε) t-s r max ≤ r max (1/ε)(1 -ε) t , w t [r] ≤ (1 -O(n 0.002 ))ε/δr max , and thus v t [r] = S/w t [r] ≤ (1 + O(n 0.002 ))r 2 max (1/δ)(1 -ε) t =: L.
Since in the remaining run of the algorithm no positive update to v[r] is made, we have v t+i [r] ≤ L for all i ≥ 1.

We now estimate v t+i [1]. We have

S t+i := t+i s=1 1 rs=r (1 -ε) t+i-s (f (x s ) - f (x s-1 )) ≥ (1 -ε) i t s=1 1 rs=r (1 -ε) t-s (f (x s ) -f (x s-1 )) = (1 -ε) i r t [1] ≥ (1 - ε) i (1 -O(n -0.002 ))E(X 1 d(xt) ) ≥ (1 -ε) i (1 -O(n -0.002 ))(d(x t )/n) = (1 -ε) i (1 - O(n -0.002 ))n -0.97 . Consequently, again using Lemma 3.34, we have v t+i [1] = S t+i /w t+i [r] ≥ (1 -ε) i (1 -O(n -0.002
))n -0.97 /(δ/r max ε). Comparing this to L above, we see that v t+i [1] is significantly larger than v t+i [r], r ≥ 2, as long as, e.g., i ≤ 0.24n ln n =: t . Hence for the remaining t iterations, our algorithm performs 1-bit flips (apart from the few learning-iterations). Consequently, -δ) . By Markov's inequality, the probability that the algorithm has not found the optimum until iteration t + t thus is at most n -0.2(1-δ) . Consequently, apart from this failure probability, our algorithm has also chosen the optimal r, in this case r = 1, in the time interval [t..T ].

E(d(x t+i )) ≤ d(x t )(1 -1-δ n ) t ≤ n 0.04 exp(-(1 -δ)(1/n)t ) = n -0.2(1

Theorem 3.38. Let T rmax be the minimal expected runtime on the OneMax problem among all randomized local search algorithms with fitness dependent mutation strength. Then the expected runtime T of our algorithm A is at most T rmax + o(n).

Consequently, by taking r max large enough, our algorithm has the same expected runtime (apart from o(n) terms) as the algorithm using the near-optimal fitnessdependent mutation strength of Algorithm à * ε (cf. Section 3.3). Also, with any fixedbudget of B ≥ 0.2675n iterations, it computes a solution approximately 13% closer to the optimum than the classic RLS heuristic.

Proof. Denote by RLS(r max ) the class of all randomized local search algorithms for functions f : {0, 1} n → [0..n] with fitness dependent mutation strength r : [0..n] → [0..r max ]. Let A max ∈ RLS(r max ) be the randomized local search algorithm with in each iteration t flips that number r ∈ [1..r max ] of bits that maximizes the expected progress E(f (x t )f (x t-1 )). Let A * ∈ RLS(r max ) be the randomized local search algorithm with minimal expected optimization time (on f = OneMax). In Section 3.2, it has been shown that the expected runtimes of both algorithms differ by at most o(n), that is, E(T Amax ) ≤ E(T A * ) + o(n). We show the assertion of this theorem by showing that our algorithm A has an expected runtime satisfying

E(T A ) ≤ E(T Amax ) + o(n).
Denote the maximum expected progress from a search point x with fitness distance d(x) by h max (d(x))

:= max{E(X r d(x) ) | r ∈ [1..r max ]}. Assume first that our algorithm A for the first T = min{T A , 2n ln(n)} iterations has E(X r * t d(x t-1 ) ) ≥ (1 -O(n -0.002 ))h max (d(x t-1
)) in each non-learning iteration (this is the good case in Theorem 3.37). Then in each iteration t ∈ [1.

.T ], we have h(d(x t-1 ))

:= E(f (x t ) -f (x t-1 )) ≥ (1 -δ)(1 -O(n -0.002 ))h max (d(x t-1
)) by ignoring possible progress in learning iterations. By the variable drift theorem, as in Section 2.4, we have that the expected time taken from a fixed initial search point x 0 to a fitness distance of, say, 0.1n, is

f (x 0 ) 0.1n 1
h(t) dt + o(n).
Since h and h max are so close, this equals f (x 0 ) 0.1n 1 hmax(t) dt + o(n), which, again as shown in Section 3.2 via the variable drift theorem for lower bounds, is a lower bound for the time A max needs to optimize x 0 to a fitness distance of 0.1n. From a fitness distance of 0.1n on, A max does only 1-bit flips and A does only 1-bit flips apart from the learning iterations. Consequently, the classic coupon collector argument shows that A max needs at least 0.1n-rmax i=1 (n/i) iterations to reach the optimum from the first search point reached that has fitness distance at most 0.1n, whereas A max does take at most 0.1n i=1 (n/i(1δ)) iterations from any search point with fitness distance 0.1n or less. Again, these terms are equal apart from o(n) terms, showing our claim for the good case of Theorem 3.37 assuming that the initial search point has a fitness distance of at least 0.1n.

In the exceptional case of Theorem 3.37, which occurs with probability at most O(n -0.19 ), or in the regular case of the theorem but for an initial search point with fitness distance less than 0.1n (which occurs with probability exp(-Ω(n))), we argue as follows. By only regarding the learning iterations and only those in which r t = 1 was chosen, we see that the expected time to reduce a fitness distance of d (by at least one) is at most (n/dδr max ). This gives an upper bound for the expected runtime of O(n log(n)/δ) = O(n 1.01 log n). Since these exceptional cases occur only with probability O(n -0.19 ), they contribute at most o(n) to the expected runtime of

A.

Since we have essentially the same (variable) drift as à * ε from Section 3.3, the proof for the second statement on the fixed-budget performance follows from the same arguments in Section 3.5.

Experimental Results

In this section we describe some experimental results for our self-adjusting RLS. These are by no means intended to account for a thorough scientific investigation, both for reasons of space and because we feel that the mathematical investigation in the subsequent section is more insightful, also with respect to why the proposed ideas work well. Nevertheless, the experimental results indicate that our new algorithm gives good results also for problems other than OneMax, they give some hints on how to choose the parameters r max , δ and ε, and they taught us that finding suitable parameters was not very difficult-we were immediately faster than the (1+1) EA and with at most a few trials were able to beat RLS. All experiments were repeated 20 times, all numbers given below are the averages of these 20 runs.

LeadingOnes function:

The LeadingOnes function is defined by

LeadingOnes(x) := max{i ∈ [0..n] | ∀j ≤ i : x j = 1}
, that is, it counts, starting from the left end, how many consecutive ones the bit-string x contains.

The expected optimization time (number of iterations until the optimum is found) for RLS is 0.5n 2 ± O(n), that of the (1+1) EA with mutation rate p = 1/n is 0.5n

2 (1 -1/n)((1 -1/n) -n -1) = 0.5(e -1)n 2 ± O(n) ≈ 0.8591n 2 .
When taking the asymptotically optimal mutation rate of approximately 1.59, the optimization time drops to approximately 0.7720n 2 . When taking a (best-possible) fitnessdependent mutation rate of p i = 1/(i + 1) at fitness i, then the optimization time drops to (e/4)n

2 ± O(n) ≈ 0.6796n 2 [BDN10].
Experimentally, for n = 10, 000 and taking the parameters r max = 5, δ = 0.1 and ε = 1/(5, 000, 000), we observed an average optimization time of 45.5 million iterations, that is, 0.455n 2 , which clearly beats RLS and all (1+1) EA results described above. The relative standard deviation is low, 4.48% to be precise.1

Minimum spanning trees: Given a connected undirected graph G = (V, E) with edge weights w : E → R >0 , the minimum spanning tree problem asks for finding a tree in G that connects all vertices and that has minimal total weight. This problem can be solved via evolutionary methods by taking a bit-string representation (each bit describes whether some edge is part of the tree or not) and taking as fitness function (to be minimized) the sum of the weights of the edges in the string representation plus a punishment term for each connected component (except the first one). For this representation of the problem, both RLS (flipping one or two bits with equal probability) and the (1+1) EA find an optimal solution in any input in expected time O(|E| 2 log(|E|w max ), where w max is the maximum weight of an edge (see [START_REF] Neumann | Randomized local search, evolutionary algorithms, and the minimum spanning tree problem[END_REF]).

We ran the following experiments. We took as graph G the complete graph on 50 vertices (hence |E| = 1225) with edge weights chosen independently at random in [0, 1], thus having a unique minimum spanning tree. On this instance, RLS in the variant that flips either one or two bits (random choice between these two alternatives) took 4.68 • 10 6 ± 38.43% iterations. Our algorithm with r max = 5, δ = 0.1, and ε = 1/(20, 000) took 2.66 • 10 6 ± 30.05% iterations. Analyzing these runs in more detail, we observe that the preferred mutation strength r after a short initial phase takes the maximum value 5, then decreases to one, and finally goes back to two, which is then used for the large remainder of the optimization process. For reasons of computation time, we could not evaluate the (1+1) EA on graphs on 50 vertices. For graphs on 20 vertices, the (1+1) EA was roughly 4 times slower that RLS.

Chapter 4

Self-adjusting (1+λ) EA

In this chapter, we propose a way to adjust the mutation rate on the fly for algorithms using larger offspring populations. The simple idea is to create half the offspring with twice the current mutation rate and the other half using half the current rate. The mutation rate is then modified to the rate which was used to create the best of these offspring (choosing the winning offspring randomly among all best in case of ambiguity). We do not allow the mutation probability to leave the interval [2/n, 1/4], so that the probability used in the subpopulations are always in the interval [1/n, 1/2].

We add one modification to the very basic idea described in the first paragraph of this section. Instead of always modifying the mutation rate to the rate of the best offspring, we shall take this winner's rate only with probability a half and else modify the mutation rate to a random one of the two possible values (twice and half the current rate). Our motivation for this modification is that we feel that the additional random noise will not prevent the algorithm from adjusting the mutation rate into a direction that is more profitable. However, the increased amount of randomness may allow the algorithm to leave a possible basin of attraction of a locally optimal mutation rate. Observe that with probability Θ(1/n 2 ), a sequence of log 2 n random modifications all in the same direction appears. Hence with this inverse-polynomial rate, the algorithm can jump from any mutation rate to any other (with the restriction that only a discrete set of mutation rates can appear). We note that the existence of random modifications is also exploited in our runtime analysis, which will show that the new self-adjusting mechanism selects mutation rates good enough to lead to the asymptotically optimal runtime among all dynamic choices of the mutation rate for the (1+λ) EA.

In this first work proposing this mechanism, we shall not spend much effort finetuning it, but rather show in a proof-of-concept manner that it can find very good mutation rates. In a real application, it is likely that better results are obtained by working with three subpopulations, namely an additional one using (that is, exploiting) the current mutation rate. Also, it seems natural that more modest adjustments of the mutation rate, that is, multiplying and dividing the rate by a number F that is smaller than the value F = 2 used by our mechanism, is profitable. We conduct some elementary experiments supporting this intuition in Section 4.7.

To prove that the self-adjusting mechanism just presented can indeed find good dynamic mutation rates, we conduct a rigorous runtime analysis for our self-adjusting (1+λ) EA on the classic test function OneMax.

The runtime of the (1+λ) EA with fixed mutation rates on OneMax is well understood [DK15; GW17]. In particular, [START_REF] Gießen | The interplay of population size and mutation probability in the (1+λ) EA on OneMax[END_REF] show that the expected runtime (number of generations) is (1

± o(1)) 1 2 • n ln ln λ ln λ + e r r • n ln n λ
when a mutation rate of r/n, r a constant, is used. Thus for λ not too large, the mutation rate determines the leading constant of the runtime, and a rate of 1/n gives the asymptotically best runtime.

As a consequence of their work on parallel black-box complexities, Badkobeh, Lehre, and Sudholt [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] showed that the (1+λ) EA with a suitable fitnessdependent mutation rate finds the optimum of OneMax in an asymptotically better runtime of O( n log λ + n log n λ ), where the improvement is by a factor of Θ(log log λ).1 This runtime is best-possible among all λ-parallel unary unbiased black-box optimization algorithms. In particular, no other dynamic choice of the mutation rate in the (1+λ) EA can achieve an asymptotically better runtime. The way how the mutation rate depends on the fitness in the above result, however, is not trivial. When the parent individual has fitness distance d, then mutation rate employed is p = max{ ln λ n ln(en/d) , 1 n }. Our main technical result is that the (1+λ) EA adjusting the mutation rate according to the mechanism described above has the same (optimal) asymptotic runtime. Consequently, the self-adjusting mechanism is able to find on the fly a mutation rate that is sufficiently close to the one proposed in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] to achieve asymptotically the same expected runtime.

Theorem 4.1. Let λ ≥ 45 and λ = n O(1) . Let T denote the number of generations of the (1+λ) EA with self-adjusting mutation rate to minimize OneMax. Then,

E(T ) = Θ n log λ + n log n λ .
This corresponds to an expected number of function evaluations of Θ( λn log λ + n log n). To the best of our knowledge, this is the first time that a simple mutation-based EA achieves a super-constant speed-up via a self-adjusting choice of the mutation rate.

As an interesting side remark, our proofs reveal that a quite non-standard but fixed mutation rate of r = ln(λ)/2 also achieves the Θ(log log λ) improvement as it implies the bound of Θ(n/ log λ) generations if λ is not too small. Hence, the constant choice r = O(1) as studied in [START_REF] Gießen | The interplay of population size and mutation probability in the (1+λ) EA on OneMax[END_REF] does not yield the asymptotically optimal number of generations unless λ is so small that the n log n-term dominates. Lemma 4.2. Let λ ≥ 45 and λ = n O(1) , Let T denote the number of generations of the (1+λ) EA with fixed mutation rate r = ln(λ)/2. Then,

E(T ) = O n log λ + n log n √ λ .

This corresponds to an expected number of function evaluations of

O λn log λ + √ λn log n .
This chapter is structured as follows: In Section 4.1 we give the algorithm and the mutation scheme. Afterwards, Section 4.2 gives a high-level overview of our main proof strategy. The following technical sections deal with the runtime analysis of the expected time spent by the (1+λ) EA on OneMax in each of three regions of the fitness distance d. We label these regions the far region, middle region and near region, each of which will be dealt with in a separate section. The proof of the main theorem and of Lemma 4.2 is then given in Section 4.6. Finally, we conduct some elementary experiments supporting this intuition in Section 4.7.

Algorithm

We consider the (1+λ) EA with self-adjusting mutation rate for the minimization of pseudo-boolean functions f : {0, 1} n → R, defined as Algorithm 8.

The general idea of the mutation scheme is to adjust the mutation strength according to its success in the population. We perform mutation by applying standard bit mutation with two different mutation probabilities r/(2n) and 2r/n and we call r the mutation rate. More precisely, for an even number λ ≥ 2 the algorithm creates λ/2 offspring with mutation rate r/2 and with 2r each.

The mutation rate is adjusted after each selection. With probability a half, the new rate is taken as the mutation rate that the best individual (i. e. the one with the lowest fitness, ties broken uniformly at random) was created with (success-based adjustment). With the other 50% probability, the mutation rate is adjusted to a random value in {r/2, 2r} (random adjustment). Note that the mutation rate is adjusted in each iteration, that is, also when all offspring are worse than the parent and thus the parent is kept for the next iteration.

If an adjustment of the rate results in a new rate r outside the interval [2, n/4], we replace this rate with the corresponding boundary value. Note that in the case of r < 2, a subpopulation with rate less than 1 would be generated, which means flipping less than one bit in expectation. At a rate r > n/4, a subpopulation with rate larger than n/2 would be created, which again is not a very useful choice.

We formulate the algorithm to start with an initial mutation rate r init . The only assumption on r init is to be greater than or equal to 2. The (1+λ) EA with this self-adjusting choice of the mutation rate is given as pseudocode in Algorithm 8.

Algorithm 8 (1+λ) EA with two-rate standard bit mutation Select x uniformly at random from {0, 1} n and set r ← r init .

for t ← 1, 2, . . . do for i ← 1, . . . , λ do Create x i by flipping each bit in a copy of x independently with probability r t /(2n) if i ≤ λ/2 and with probability 2r t /n otherwise.

x * ← arg min

x i f (x i ) (breaking ties randomly). if f (x * ) ≤ f (x) then x ← x * .
Perform one of the following two actions with prob. 1/2: -Replace r t with the mutation rate that x * has been created with.

-Replace r t with either r t /2 or 2r t , each with probability 1/2. Replace r t with min{max{2, r t }, n/4}.

Let us explain the motivation for the random adjustments of the rate. Without such random adjustments, the rate can only be changed into some direction if a winning offspring is generated with this rate. For simple functions like OneMax, this is most likely sufficient. However, when the fitness of the best of λ/2 offspring, viewed as a function of the rate, is not unimodal, then several adjustments into a direction at first not yielding good offspring might be needed to reach good values of the rate. Here, our random adjustments enable the algorithm to cross such a valley of unfavorable rate values. We note that such ideas are not uncommon in evolutionary computation, with standard-bit mutation being the most prominent example (allowing to perform several local-search steps in one iteration to cross fitness valleys).

A different way to implement a mechanism allowing larger changes of the rate to cross unfavorable regions would have been to not only generate offspring with rates r/2 and 2r, but to allow larger deviations from the current rate with some small probability. One idea could be choosing for each offspring independently the rate r2 -i with probability 2 -|i|-1 for all i ∈ Z, i = 0. This should give similar results, but to us the process appears more chaotic (e.g., with not the same number of individuals produced with rates r/2 and 2r).

The runtime, also called the optimization time, of the (1+λ) EA is the smallest t such that an individual of minimum f -value has been found. Note that t corresponds to a number of iterations (also called generations), where each generation creates λ offspring. Since each of these offspring has to be evaluated, the number of function evaluations, which is a classical cost measure, is by a factor of λ larger than the runtime as defined here. However, assuming a massively parallel architecture that allows for parallel evaluation of the offspring, counting the number of generations seems also a valid cost measure. In particular, a speed-up on the function

OneMax(x 1 , . . . , x n ) := x 1 + • • • + x n
by increasing λ can only be observed in terms of the number of generations. Note that for reasons of symmetry, it makes no difference whether OneMax is minimized (as in the present paper) or maximized (as in several previous research papers).

Throughout the chapter, all asymptotic notation will be with respect to the problem size n.

Proof Overview

Since the following runtime analysis of our self-adjusting (1+λ) EA on the One-Max function is slightly technical, let us outline the main proof ideas here in an informal manner. Let always x denote the parent individual of the current iterations and k := f (x) its fitness distance from the optimum (recall that we are minimizing the OneMax function, hence the fitness distance equals the objective function value which in turn is the Hamming distance from the optimum x * = (0, . . . , 0) ∈ {0, 1} n and thus the number of ones in x).

The outer proof argument is variable drift, that is, for each fitness value k we estimate the expected fitness gain ("progress") in an iteration starting with a parent individual x with f (x) = k and then we use the variable drift theorem (Theorem 2.4) to translate this information on the progress into an expected runtime (number of generations until the optimum is found).

To obtain sufficiently strong lower bounds on the expected progress, we need to argue that the rate self-adjustment sufficiently often sets the current rate to a sufficiently good value. This is the main technical difficulty as it needs a very precise analysis of the quality of the offspring in both subpopulations. Since this requires different arguments depending on the current fitness distance k, we partition the process into three regimes.

In the far region covering the fitness distance values k ≥ n/ ln(λ), we need a rate r that is at least almost logarithmic in λ to ensure that the average progress is high enough. Note that to gain the Θ(n) fitness levels from the initial value of approximately n/2 to n/ ln λ in at most a time of O(n/ log λ), we need an average progress of Ω(ln λ) per iteration. We shall not be able to obtain this progress throughout this region, but we will obtain an expected progress of Ω log λ log en k in an iteration with initial fitness distance k. This will be sufficient to reach a fitness distance of n/ log λ in the desired O(n/ log λ) iterations.

As said, the main difficulty is arguing that the self-adjusting mechanism keeps the rate sufficiently often in the range we need, which is roughly

1 2 ln en k ln λ, 4n 2 (n -2k) 2 ln λ for all k ∈ [n/ ln λ, n/2 -1].
Note that these range boundaries, in particular the upper one, depend strongly on k. Hence for arguing that our rate is sufficiently often in this range, we need to consider both the rate changes from the self-adjustments and the changing k-value. In this region we profit from the fact that we work with relatively high rates, which lead to strong concentration behaviors. This allows to argue that, for example, exceeding the upper boundary already by small constant factors is highly unlikely.

The middle region covering the fitness distances k ∈ [n/λ, n/ ln λ] is small enough so that we do not require the algorithm to find a near-optimal rate very often. In fact, it suffices that the rate is below 1 2 ln λ with constant probability. This ensures an expected progress of at least min{ 1 8 , √ λk/32n}, which is sufficient to traverse also this region in time O(n/ log λ). Consequently, in this region we only need to argue that the rate does not become too large, whereas there is no lower bound on r which we require. Further, the upper bound of 1 2 ln λ is large enough so that strong concentration arguments can be exploited, which show that deviations above the upper bound are highly unlikely. Since the upper bound does not change over time, we can now conveniently use an occupation probability argument to show that the rate with constant probability is only a small constant factor over the desired range, which is enough since the random fluctuations of the rate with constant probability reduce the rate further to the desired range.

In the near region covering the remaining fitness distance values k ≤ n/λ, the parent individual is already so close to the optimum that any rate higher than the minimal rate r = 2 is sub-optimal. Hence in this region, we know precisely the optimum value for the rate. Nevertheless, it is not very easy to show that the subpopulation using the smaller rate r/2 has a higher chance of containing the new parent individual. Due to the small rates predominant in this region and the fact that progress generally is difficult (due to the proximity to the optimum), often both subpopulations will contain best offspring (which are in fact copies of the parent). Hence the typical reason for the winning offspring stemming from the smaller-rate subpopulation is not anymore that the other subpopulation contains only worse individuals, but only that the smaller-rate subpopulation contains more best offspring.

By quantifying this effect we establish a drift of the rate down to its minimum value 2 in the near region, and another occupation probability argument is used to show that the rate with sufficiently high probability will take this value in subsequent sets. Nevertheless, the concentration of the rate around this target value is weaker than in the other regions, and additional care has to be taken to handle iterations in the near region in which the unlikely, but still possible event occurs that the rate exceeds ln λ. This value is a critical threshold in the near region since rates larger than ln λ will typically make all offspring worse than the parent. As an additional obstacle, there is a small interval of rates above the threshold in which we cannot show a drift of the rate to its minimum. To show that this small interval nevertheless is left towards its lower end with probability Ω(1), the occupation probability argument is combined with a potential function whose shape exploits the random adjustments that the (1+λ) EA performs with 50% probability.

The Far Region

In this first of three technical sections, we analyze the optimization behavior of our self-adjusting (1+λ) EA in the regime where the fitness distance k is at least n/ ln λ. Since we are relatively far from the optimum, it is relatively easy to make progress. On the other hand, this regime spans the largest number of fitness levels (namely Θ(n)), so we need to exhibit a sufficient progress in each iteration. Also, this is the regime where the optimal mutation rate varies most drastically. Since it is not important for the following analysis, we remark without proof that the optimal rate is n for k

≥ n/2 + ω( √ n log λ), (1 + o(1))n/2 for k = n/2 ± o( √ n log λ)
, and then quickly drops to r = Θ(log λ) for k ≤ n/2εn. Despite these difficulties, our (1+λ) EA manages to find sufficiently good mutation rates to be able to reach a fitness distance of k = n/ ln λ in an expected number of O(n/ log λ) iterations. Lemma 4.3. Let n be sufficiently large and 0 < k < n/2. We define c 1 (k) = (2 ln(en/k)) -1 and c 2 (k) = 4n 2 /(n -2k) 2 .

1. If n/ ln λ ≤ k and r ≤ c 1 (k) ln λ, then the probability that a best offspring has been created with rate 2r is at least 0.64.

2. Let λ ≥ 100. If c 2 (k) ln λ ≤ r ≤ n/4
, then the probability that all best offspring have been created with rate r/2 is at least 0.51.

3. If r ≥ 2(1 + γ)c 2 (k) ln λ, then the probability that all best offspring are worse than the parent is at least 1λ -γ .

Proof of Lemma 4.3 part 1. Let q(k, i, r) and Q(k, i, r) be the probabilities that standard bit mutation with mutation rate p = r/n creates from a parent with fitness distance k an offspring with fitness distance exactly ki and at most ki. Then

q(k, i, r) = k-i j=0 k i + j n -k j r n i+2j 1 - r n n-i-2j
and Q(k, i, r) = k j=i q(k, j, r). We first show that the probability of not achieving i ≥ 2r is less than 0.2. This is because for large enough n and r ≥ 2 we have

(1 -o(1))( k 2r ) ≥ (1 -o(1))4!(k/(2r)) 2r > 4(k/(2r)) 2r and for r ≤ c 1 (k) ln λ = o( √ n) by Lemma 2.14, part 3 we have (1 -2r/n) n ≥ e -2r-4r 2 /n = (1 -o(1))e -2r , thus Q(k, 2r, 2r) ≥ q(k, 2r, 2r) ≥ k 2r 2r n 2r 1 - 2r n n ≥ 4 k 2r 2r 2r n 2r e -2r ≥ 4 k en 2r ≥ 4 k en 2c 1 (k) ln λ = 4 λ .
Considering λ/2 offspring using rate 2r, the probability that none of them achieves a fitness improvement of at least 2r is less than (1 -4/λ) λ/2 < exp(-4/2) < 0.2. We next argue that an offspring having a progress of 2r or more with good probability comes from the 2r-subpopulation. We notice that

q(k, i, 2r) q(k, i, r/2) ≥ 4 i 1 -2r/n 1 -r/(2n) n ≥ 1 -o(1) 4 i e -1.5r .
Thus for r ≥ 2 and i ≥ 2r we have

q(k, i, 2r) q(k, i, r/2) ≥ 1 -o(1) 4 e 2r > 4.
Therefore if the best progress among all λ offspring is i and i ≥ 2r, the conditional probability that an offspring having fitness distance ki is generated with rate 2r is at least q(k, i, 2r)/(q(k, i, 2r) + q(k, i, r/2)) ≥ 4/5. In total, the probability that a best offspring has been created with rate 2r is at least

(1 -0.2) • 4/6 = 0.64.
Proof of Lemma 4.3 part 3. Let λ ≥ 100 and c 2 (k) ln λ ≤ r ≤ n/4. Our idea is to show a probability of o(1/λ) for the event that an offspring with rate 2r is not worse than the expected fitness of an offspring with rate r/2. Let X(k, r) denote the random decrease of the fitness distance when applying standard bit mutation with probability p = r/n to an individual with k ones. Then

E(X(k, r)) = kp -(n -k)p = (2k -n)r n , Var(X(k, r)) = np(1 -p) = r 1 - r n .
According to Bernstein's inequality (Theorem 2.8 1), for any ∆ > 0 we have

Pr(X ≥ E(X) + ∆) ≤ exp -∆ 2 2 Var(X) + 2∆/3 ≤ exp -∆ 2 2 Var(X) + 2∆
We apply this bound with X = X(k, 2r) and

∆ = E(X(k, r/2)) -E(X(k, 2r)) = (n -2k)1.5r/n > 0. Then, Pr(X(k, 2r) ≥ E(X(k, r/2))) ≤ exp -∆ 2 2 Var(X(k, 2r)) + 2∆ = exp -9(n -2k) 2 r 4n(7n -8r -6k) ≤ exp - 9(n -2k) 2 c 2 (k) ln λ 28n 2 = 1 λ 9/7 .
We notice that we have 7n -8r -6k > 7n -4n -3n = 0 in the second inequality.

From a union bound we see that with probability less than λ -9/7 (λ/2) < 100 -2/7 /2 < 0.14, the best offspring created with rate 2r is at least as good as the expected fitness of an individual created with rate r/2. We estimate the probability that the best offspring using rate r/2 has a fitness distance at most E(X(k, r/2)). Let y be an offspring obtained from x via standard bit mutation with mutation rate r/(2n). Let X + and X -be the number of one-bits flipped and zero-bits flipped, respectively.

X + := |{i ∈ {1, . . . , n} | x i = 1 ∧ y i = 0}|, X -:= |{i ∈ {1, . . . , n} | x i = 0 ∧ y i = 1}|.
Both X + and X -are binomially distributed and X(k, r/2) = X + -X -. We aim at a lower bound for Pr(X(k, r/2) ≥ E(X(k, r/2))). We have Pr(X + ≥ E(X + ) -1) ≥ 1/2, since the median of X + is between E(X + ) and E(X + ) by [START_REF] Kaas | Mean, Median and Mode in Binomial Distributions[END_REF]. It remains to bound Pr(X -≤ E(X -) -1). We notice that E(X -) = (nk)r/(2n) > ln λ > 1 and E(X -) ≤ (nk)/4. Applying Lemma 2.16 to binomial random variable X-:=

(n -k) -X -, we obtain Pr(X -≤ E(X -) -1) = Pr( X-≥ E( X-) + 1) ≥ 0.037. Therefore Pr(X(k, r/2) ≥ E(X(k, r/2))) ≥ Pr(X -≤ E(X -) -1) Pr(X + ≥ E(X + ) -1) ≥ 0.037 • 0.5 = 0.0185.
For λ/2 offspring using rate r/2, the probability that the best one has a fitness distance at most E(X(k, r/2)) is more than 1 -(1 -0.0185) λ/2 ≥ 1 -0.9815 50 ≥ 0.6. Therefore with probability at least 0.6 • (1 -0.14) > 0.51, all best offspring are from the r/2-subpopulation. This proves the second statement of the lemma.

Proof of Lemma 4.3 part 2. Let r ≥ 2(1 + γ)c 2 (k) ln λ. An offspring created with mutation rate r/n is at least as good as its parent if and only if X(k, r) ≥ 0. By using Bernstein's inequality (Theorem 2.8 1) with X = X(k, r) and ∆ = -E(X(k, r)), we have

Pr(X(k, r) ≥ 0) ≤ exp - E(X(k, r)) 2 2 Var(X(k, r)) + 2E(X(k, r)) = exp - (n -2k) 2 r 2n(2n -2k -r) ≤ exp - (n -2k) 2 r 4n 2 .
Since r ≥ 2(1 + γ)c 2 (k) ln λ, the corresponding probabilities for rate r/2 and 2r are at most 1/λ 1+γ and 1/λ 4+4γ , respectively. By a union bound, with probability at most 1/λ γ , the best offspring is at least as good as its parent. This proves part 3.

The lemma above shows that the rate r is subject to a constant drift towards the interval [c 1 (k) ln n, c 2 (k) ln n]. Unfortunately, we cannot show that we obtain a sufficient fitness progress for all r-values in this range. However, we can do so for a range smaller only by constant factors. This is what we do now (for large values of k) and in Lemma 4.5 (for smaller values of k). This case distinction is motivated by the fact that c 2 (k) becomes very large when k approaches n/2. Having a good fitness drift only for such a smaller range of r-values is not a problem since the random movements of r let us enter the smaller range with constant probability. This is what we will exploit in Theorem 4.6 and its proof.

Let 2 ≤ r ≤ n/4 be the current rate and let r ∈ {r/2, 2r}. Let ∆(λ/2, k, r) denote the fitness gain of the best of λ/2 offspring generated with rate r from a parent x with fitness distance k := OneMax(x) and the parent itself. More precisely, let x (i) , i ∈ {1, . . . , λ/2}, be independent offspring generated from x by flipping each bit independently with probability r/n. Then the random variable ∆(λ/2, k, r) is defined by max{0, k -min{OneMax(x (i) ) | i ∈ {1, . . . , λ/2}}}. We use ∆ := max{ ∆(λ/2, k, r/2), ∆(λ/2, k, 2r)} to denote the fitness gain in a iteration which uses x as parent and r as mutation rate.

We next show that a region contained in [c 1 (k) ln λ, c 2 (k) ln λ] provides at least a logarithmic (in λ) drift on fitness.

Lemma 4.4. Let n be sufficiently large, 2n/5 ≤ k < n/2 and λ ≥ e 10 . If

ln(λ) ≤ r ≤ min{n 2 ln(λ)/(25(n -2k) 2 ), n/4}, then E(∆ | k) ≥ 10 -6 ln λ.
Proof. We first notice that n 2 /(25(n -2k) 2 ) ≥ 1/(25 • 0.2 2 ) = 1 for all 2n/5 ≤ k < n/2. We aim to prove ∆(λ/2, k, r) ≥ 10 -5 ln λ with r = r/2. If r ≤ 13, the probability that an offspring using rate r/n achieving a fitness distance of k -

1 is at least k 1 r n 1 - r n n-1 ≥ (1 -o(1))0.4e -r > 9 • 10 -7 .
For λ/2 offspring using rate r ≤ 13,

Pr(∆ ≥ 1 | k) ≥ 1 -1 -9 • 10 -7 λ/2 > 9 • 10 -3 for all λ > e 10 .
This satisfies the statement that E(∆ | k) ≥ 10 -6 ln λ since ln λ ≤ 2 r ≤ 26. Therefore, it remains to consider r > 13. Let X + and X -be the number of one-bits flipped and zero-bits flipped, respectively, in an offspring using rate p = r/n. X + and X -follow binomial distributions Bin(k, p) and Bin(nk, p), respectively. Let u := E(X + ) = kp and ũ = u . Then

u ≤ k/8, u ≥ (k/n) r ≥ 5.2, and u ≥ (k/n) ln(λ)/2 ≥ 0.4 • 0.5 • ln λ = 0.2 ln λ. Furthermore, let B(x) := Pr(X + = x) = k x p x (1 -p) k-x for all x ∈ {0, 1, . . . , k}, F (x) := Pr(X + ≥ x) = k i= x B(i) for all x ∈ [0, k].
Applying Lemma 2.16, we obtain

F (u) = Pr(X + ≥ E(X + )) ≥ 1/4. Similarly Pr(X -≤ E(X -)) ≥ 1/4. We prove that for δ := E(X -) -E(X + ) + 0.02 ln λ = (n -2k)p + 0.02 ln λ , we have F (u + δ) ≥ λ -0.
36 /e 13 , and thus Pr(X + -X -≥ 0.02 ln λ) ≥ λ -0.36 /(4e 13 ). Since for any x ∈ Z ≥u we have

B(x + 1) B(x) = k -x x + 1 • p 1 -p ≤ u -up u -up + 1 -p < 1, we obtain B( ũ) > B( ũ + 1) > • • • > B(k)
, and thus F (u + δ) ≥ δB( ũ + 2δ) as well as δB( ũ) ≥ F (u) -F (u + δ). We see that

B( ũ + 2δ) B( ũ) = (k -ũ) • • • (k -ũ -2δ + 1) ( ũ + 1) • • • ( ũ + 2δ) • p 2δ (1 -p) 2δ ≥ k -u -2δ k(1 -p) 2δ u 2δ ( ũ + 1) • • • ( ũ + 2δ) ≥ 1 - 2δ 7u 2δ u 2δ ( ũ + 1) • • • ( ũ + 2δ)
,

where we used k(1 -p) = k -u ≥ 8u -u = 7u.
Using a sharp version of Stirling's approximation due to Robbins [START_REF] Robbins | A Remark on Stirling's Formula[END_REF], we compute

( ũ + 2δ)! ≤ 2π( ũ + 2δ) ( ũ + 2δ) e ũ+2δ exp 1 12( ũ + 2δ) , ũ! ≥ √ 2π ũ ũ e ũ exp 1 12 ũ + 1 .
Notice that 12 ũ + 1 < 12( ũ + 2δ), we obtain 1

( ũ + 1) • • • ( ũ + 2δ) = ũ! ( ũ + 2δ)! ≥ ũ ũ + 2δ ũ ũe 2δ ( ũ + 2δ) ũ+2δ ≥ ũ ũ + 2δ u ũe 2δ ( ũ + 2δ) ũ+2δ . Therefore B( ũ + 2δ) B( ũ) ≥ 1 - 2δ 7u 2δ ũ ũ + 2δ u ũ+2δ e 2δ ( ũ + 2δ) ũ+2δ ≥ ũ ũ + 2δ exp 2δ ln 1 - 2δ 7u + ( ũ + 2δ) ln 1 - 2δ + 1 ũ + 2δ + 2δ .
We notice that u ≥ max{0.2 ln λ, 5.2} and

(n -2k)p + 0.02 ln λ ≤ 0.2np + 0.02 ln λ ≤ 0.5u + 0.02 ln λ < 0.6u.

Thus δ < u and ũδ ≥ 0.4u -1 > 1. Since ũδ is an interger, ũδ ≥ 2. Therefore 2δ/(7u) < 1/2 and (2δ + 1)/( ũ + 2δ) < 2/3. By Lemma 2.14 item 3 and 4, we have ln(1x) ≥ -xx 2 for 0 ≤ x ≤ 2/3 and ln(1x) ≥ -3x/2 for 0 ≤ x ≤ 1/2. We compute

2δ ln 1 - 2δ 7u ≥ - 3 2 • 4δ 2 7u ≥ - δ 2 u , ( ũ + 2δ) ln 1 - 2δ + 1 ũ + 2δ ≥ -(2δ + 1) - (2δ + 1) 2 ũ + 2δ ≥ -2δ - 4δ 2 u -3, B( ũ + 2δ) B( ũ) ≥ 1 3 exp - 5δ 2 u -3 > exp(-0.36 ln λ -11).
where in the last inequality, using ln(λ)/2 ≤ r ≤ n 2 ln(λ)/(50(n -2k) 2 ), we estimate

5δ 2 u ≤ 5((n -2k) r/n + 0.02 ln λ + 1) 2 k r/n = 5n k (n -2k) 2 r n 2 + 2(n -2k)0.02 ln λ n + (0.02 ln λ) 2 r + 2(n -2k) n + 2 • 0.02 ln λ ln(λ)/2 + 1 r ≤ 5 0.4 ln λ 50 + 2 • 0.2 • 0.02 ln λ + 0.02 2 ln λ 0.5 + 0.4 + 0.08 + 1 13 ≤ 0.36 ln λ + 7. Recalling F (u + δ) ≥ δB( ũ + 2δ) and δB( ũ) ≥ F (u) -F (u + δ), we compute F (u + δ) ≥ δB(u + 2δ) ≥ δe -0.36 ln λ-11 B(u + 2δ) ≥ e -0.36 ln λ-11 (F (u) -F (u + δ)).
Since F (u) ≥ 1/4 and λ > e 10 , we obtain

F (u + δ) ≥ e -0.36 ln λ-11 F (u)
1 + e -0.36 ln λ-11 ≥ λ -0.36 e -11 /4 1 + e -0.36•10-11 > λ -0.36 e 13 .

Using Pr(X + -X -≥ 0.02 ln λ) ≥ λ -0.36 /(4e 13 ), we bound

Pr( ∆(λ/2, k, r/2) ≥ 0.02 ln λ | k) ≥ 1 -(1 -λ -0.36 /(4e 13 )) λ/2 ≥ 1 -(1 -e -0.36•10-13 /4) e 10 /2 > 1.7 • 10 -4 . Finally E(∆ | k) ≥ 1.7 • 10 -4 • 0.02 ln λ > 10 -6 ln λ.
We now extend the lemma to the whole region of n/ ln λ ≤ k < n/2. If k < 2n/5 the situation becomes easier because 4 ≤ c 2 (k) < 100 and every r in the smaller range [c 1 (k) ln λ, ln(λ)/2] provides at least an expected fitness improvement that is logarithmic in λ. Together with the previous lemma, we obtain the following statement for the drift in the whole region n/ ln λ ≤ k < n/2. Lemma 4.5. Let n be sufficiently large, n/ ln λ ≤ k < n/2 and λ ≥ e 10 . If

c 1 (k) ln λ ≤ r ≤ c 2 (k) ln(λ)/100 with c 1 (k), c 2 (k) defined as in Lemma 4.3, then E(∆ | k) ≥ 10 -6 ln(λ)/ ln(en/k).
Proof. If r > ln(λ), then c 2 (2n/5) = 100 implies k > 2n/5 and the claim follows from Lemma 4.4. Hence let us assume r ≤ ln(λ) in the remainder and compute ∆(λ/2, k, r) with r = r/2.

We consider the probability Q(k, i, r) of creating from a parent with distance k an offspring with fitness distance at most ki via standard bit mutation with mutation rate p = r/n. 1))e -r by Lemma 2.143, we compute

Let i := max{1, c 1 (k) ln(λ)/2 } ≤ max{1, r/2} = r. If c 1 (k) ln(λ)/2 < 1, using (1 -p) n ≥ e -pn-p 2 n ≥ (1 -o(
Q(k, 1, r) ≥ kp(1 -p) n ≥ k r n (1 -p) n ≥ (1 -p) n ln λ ≥ (1 -o(1))e -ln(λ)/2 ln λ ≥ 1 λ . Otherwise if c 1 (k) ln(λ)/2 > 1, using ( k i ) ≥ (k/i) i , we obtain Q(k, i, r) ≥ k i p i (1 -p) n ≥ k i • r n i e -r-p 2 n ≥ k n i e -r-p 2 n ≥ k en i e -r ≥ k en ln λ 4 ln(en/k) e -r = e -ln(λ)/4-r ≥ e -ln λ = 1 λ . Hence, Pr( ∆(λ/2, k, r) ≥ i | k) ≥ 1 -(1 -1/λ) λ/2 ≥ 1 -e -1/2 > 0.3. We notice that i ≥ c 1 (k) ln(λ)/4, since i = 1 ≥ c 1 (k) ln(λ)/4 when c 1 (k) ln λ < 2 and i = c 1 (k) ln(λ)/2 ≥ c 1 (k) ln(λ)/4 when c 1 (k) ln λ ≥ 2. Consequently E(∆ | k) > Pr( ∆(λ/2, k, r) ≥ i | k) • i ≥ 0.3 • c 1 (k) ln(λ)/4 ≥ 10 -6 ln(λ)/ ln(en/k).
If we only consider generations that use a rate within the right region, we can bound the expected runtime to reach k ≤ n/ ln λ by O(n/ log λ) since the drift on the fitness is of order log λ. The following theorem shows that the additional time spent with adjusting the rate towards the right region does not change this bound on the expected runtime.

Theorem 4.6. The (1+λ) EA with self-adjusting mutation rate reaches a OneMaxvalue of k ≤ n/ ln λ within an expected number of O(n/ log λ) iterations. This bound is valid regardless of the initial mutation rate.

Proof. Let us denote by k(x) the fitness distance of a search point x ∈ {0, 1} n .

We first argue that it takes an expected number of at most O( √ n) iterations to reach a fitness distance of less than n/2. To this end, consider a parent x with fitness distance k(x) ≥ n/2. Let 2 ≤ r ≤ n/4 be the current rate and let r ∈ {r/2, 2r}. Let y be an offspring obtained from x via standard bit mutation with mutation rate r/n. Let

X + := |{i ∈ {1, . . . , n} | x i = 1 ∧ y i = 0}|, X -:= |{i ∈ {1, . . . , n} | x i = 0 ∧ y i = 1}|.
Then the fitness improvement is k(x)k(y) = X + -X -and both X + and X -follow binomial distributions. From elementary properties of the binomial distribution, see, e.g., Lemma 2.16, we have Pr(X + ≥ E(X + ) + 1) = Ω(1) and Pr(X -≤ E(X -)) =

Ω(1), and these are independent events. Hence with constant probability, we have

k(y) = k(x) -X + + X -≤ k(x) -E(X + ) -1 + E(X -) ≤ k(x) -1 -(2k(x) -n) r n ≤ k(x) -1.
Clearly, for the best offspring z out of the λ offspring generated in this iteration, we have k(z) ≤ k(y). Consequently, in each iteration starting with a parent x with k(x) ≥ n/2, with constant probability we gain at least one fitness level. By the additive drift theorem (see Theorem 2.4 and the subsequent discussion), from the initial random search point x 0 it takes an expected O(max{0, k(x 0 )n/2 + 1}) iterations to reach a parent with fitness distance less than n/2. Since X := k(x 0 ) ∼ Bin(n, 1/2), we have

E(max{0, X -n/2}) = 1 2 E(|X -E(X)|) ≤ 1 2 E((X -E(X)) 2 ) = 1 2 Var(X) = 1 4 √ n,
where we first exploited the symmetry of X and then the well-known estimate

E(Y ) 2 ≤ E(Y 2 ) valid for all random variables Y , in particular, for Y = |X -E(X)|.
By the law of total expectation, the expected time to reach a search point with

k-value below n/2 is O( √ n).
Without loss of generality we can now assume k < n/2 for the initial state. Our intuition is that once we begin to use a rate r ∈ [(c 1 (k)/2) ln λ, c 2 (k) ln λ] at some distance level k, we will have a considerable drift on the OneMax-value and the strong drift on the rate keeps r within or close to this interval. After we make progress and k decreases to a new level, the corresponding c 1 and c 2 decrease, and the algorithm may take some time to readjust r into new bounds.

We consider the stochastic process X t = log 2 (r t ) and the current OneMaxvalue Y t . According to Lemma 4.3 item 1 and 2, there exists

ε = Ω(1) such that Pr(X t+1 -X t | X t ; X t < log 2 (c 1 (K t ) ln λ) -1) ≥ ε, Pr(X t -X t+1 | X t ; X t > log 2 (c 2 (K t ) ln λ)) ≥ ε. Let k 0 > k 1 > • • • > k N be
O(log n) iterations to have r t ∈ [(c 1 (k 0 )/2) ln λ, c 2 (k 0 ) ln λ], regardless of how we set the initial rate. Since c 1 (Y t ) is non-increasing, r t ≥ c 1 (Y t ) ln(λ)/2 implies r t ≥ c 1 (Y t+1
) ln(λ)/2. Thus, no readjustments are necessary to satisfy the lower bound r t ≥ c 1 (Y t ) ln(λ)/2 once we have r t ≥ c 1 (k 0 ) ln(λ)/2. We now regard the upper bound condition r t ≤ c 2 (Y t ) ln(λ). Let (k s i ) be the subsequence consisting of all

k s i such that {t | r t ≤ c 2 (Y t ) ln(λ), Y t = k s i } = ∅. If k i is in the subsequence, once r t ≤ c 2 (Y t ) ln(λ)
is achieved, the runtime until the first time Y t = k i+1 can be computed using the occupation lemma and the variable drift theorem. After that, it takes at most O(log(c 2 (k i )/c 2 (k i+1 ))) more iterations to readjust r t from c 2 (k i ) ln(λ) to c 2 (k i+1 ) ln(λ) by the additive drift theorem. Similar arguments hold for k i+1 if it is also in the subsequence. Otherwise let k j < k i+1 denote the next OneMax-values after k i in the subsequence. By definition, the fitness distance decreases from k i+1 to k j before the rate being adjusted into the corresponding range. This means that improvements in distance are made during readjustment. Analogous to above, the expected (readjusting) time to decrease the rate from

c 2 (k i+1 ) ln(λ) to c 2 (k j ) ln(λ) is O(log(c 2 (k i+1 )/c 2 (k j )))
. Therefore, the expected number of total readjusting time is at most

s i+1 ≤N i=1 O log c 2 (k s i ) c 2 (k s i+1 ) = O log c 2 (k 0 ) c 2 (k N ) = O(log n).
When computing the expected number of non-adjusting iterations until Y t = k N , we choose a constant b ∈ N ≥2 large enough such that 2e -2bε/3 ≤ 1/2δ/2 holds for some positive constant δ > 0. When r t ∈ [(c 1 (k)/2) ln λ, c 2 (k) ln λ] and Y t = k for some t, then by Lemma 2.11, we obtain

Pr(r t ≥ 2 b+1 c 2 (k) ln λ) ≤ 2e -2bε/3 and Pr(r t ≤ 2 -b-2 c 1 (k) ln λ) ≤ 2e -2bε/3 for t ≥ t.
Hence, we obtain that r t ∈ [2 -b-2 c 1 (k) ln λ, 2 b+1 c 2 (k) ln λ] happens with probability at least δ. We see that there are at most log 2 (100) steps between being in the range

[(c 1 (k)/2) ln λ, c 2 (k) ln λ] and being in the smaller range [c 1 (k) ln λ, c 2 (k) ln(λ)/100] which is described in Lemma 4.5. If r t ∈ [2 -b-2 c 1 (k) ln λ, 2 b+1 c 2 (k) ln λ]
, it takes at most a constant number of iterations α in expectation to reach the smaller range [c 1 (k) ln λ, c 2 (k) ln(λ)/100] because our mutation scheme employs a 50% chance to perform a random step of the mutation rate. Based on Lemma 4.5, the fitness drift at distance k of all rates within the narrow region is at least 10 -6 ln(λ)/ ln(en/k). This contributes to an average drift of at least

10 -6 • ln(λ) ln(en/k) • δ 1 + α = Ω log(λ) log(n/k)
for all random rates at distance k. Using the variable drift theorem (Theorem 2.4), we estimate the runtime as

O log(log λ) log λ + n/2 n/ log λ log(n/k)dk log λ = O 1 log λ n/2 n/ log λ log(n) -log(k) dk =O   1 log λ log(n)k -k log(k) + log(k) n/2 n/ log λ   =O 1 log λ log(n) n 2 - n log λ - n 2 log n 2 + n log λ log n log λ + log n/2 n/ log λ =O 1 log λ n log 2 2 - n log(log λ) log λ + log(log λ) = O n log λ .
We notice that the expected runtime for adjusting

r t is O(log n) = O(n/ log λ).
Therefore, the total runtime is O(n/ log λ) in expectation.

The Middle Region

In this section we estimate the expected number of generations until the number of one-bits has decreased from k ≤ n/ ln λ to k ≤ n/λ. We first claim that the right region for r is 1 ≤ r ≤ ln(λ)/2. Hence, the (1+λ) EA is not very sensitive to the choice of r here. Intuitively, this is due to the fact that a total fitness improvement of only O(n/ log λ) suffices to cross the middle region, whereas an improvement of Ω(n) is needed for the far region.

We estimate the drift of the fitness in Lemma 4.7 and apply that result afterwards to estimate the number of generations to cross the region.

Lemma 4.7. Let n/λ ≤ k ≤ n/ ln λ, λ ≥ 26 and 2 ≤ r ≤ ln λ. Then E(∆ | k) ≥ min 1 8 , √ λk 32n .
Proof. We aim at computing ∆(λ/2, k, r) with r = r/2. The probability that no zerobit flips in a single offspring stemming from rate r is (1r/n) n-k ≥ e -r ≥ 1/ √ λ. We regard the number Z of offspring of rate r that have no flipped zeros. The expectation

E(Z) is at least (1/ √ λ) • (λ/2) = √ λ/2.
Applying Chernoff bounds (Theorem 2.8), we observe that Z exceeds λ 0 := √ λ/4 with probability at least 1 -exp(-√ λ/16) > 1/4 since λ ≥ 26. Assuming this to happen, we look at the first λ 0 offspring without flipped zeros. For i ∈ {1, . . . , λ 0 } let X i be the number of flipped ones in the i-th offspring. Then the X i are i.i.d. with X i ∼ Bin(k, r/n). Let X * := max{X i }. The expectation of X * is analyzed in [GW17, Lemma 4, part 2]; more precisely the following statement is shown for constant r:

If λ 0 k r n ≥ α then E(X * ) ≥ α 1 + α .
Since r is not necessarily assumed constant here, we generalize the result by closely following the proof in [START_REF] Gießen | The interplay of population size and mutation probability in the (1+λ) EA on OneMax[END_REF]. Note that X * ≥ 1 if at least one of the offspring does not flip a zero-bit. Hence,

E(X * ) ≥ 1 - 1 - r n k λ 0 ≥ 1 - 1 - r n αn/(λ 0 r) λ 0 ≥ 1 -e -α/λ 0 λ 0 = 1 -e -α ≥ 1 - 1 1 + α = α 1 + α ,
where the second inequality used the assumption λ 0 k r/n ≥ α, the third one e x ≥ 1 + x for x ∈ R. and the fifth one the equivalent to the previous inequality e -x ≤ 1/(1 + x). Hence, Lemma 4, part 2 in [START_REF] Gießen | The interplay of population size and mutation probability in the (1+λ) EA on OneMax[END_REF] holds also for arbitrary r.

Setting α := λ 0 k r/n, we now distinguish between two cases. If α ≥ 1, we obtain E(X * ) ≥ α/(1 + α) ≥ 1/2; otherwise we have 1 + α < 2, hence E(X * ) ≥ α/2 = λ 0 k r/(2n). Thus, E(X * ) ≥ min{1/2, √ λk/(8n)}. Hence, using the law of total probability, we obtain the lower bound on the drift for the middle region.

We now use our result on the drift to estimate the time spent in this region. We notice that c 2 (k) = 4 + o(1) when k = o(n). This means we will often have r t ∈ [2, ln(λ)] which provides the drift we need. Proof. For k ≤ n/ ln λ the upper bound from Lemma 4.3 is c 2 (k) = 4/(1 -2/ ln λ) < 11. According to the lemma we have for X t := log 2 r t that E(X t -X t+1 | X t ; X t > log 2 (c 2 (k) ln λ)) ≥ 2ε = Ω(1). The additive drift theorem yields that in O(log n) time we have r t ≤ c 2 (k) ln λ. We choose b large enough such that 2e -2bε/3 ≤ 1δ holds for some positive constant δ > 0 and note that b is constant. Applying Lemma 2.11 we obtain Pr(r t ≥ 2 b c 2 (k) ln λ) ≤ 2e -2bε/3 and r t ≤ 2 b c 2 (k) ln λ happens with probability at least δ. Once r t < 2 b c 2 (k) ln λ < 2 b (11 ln λ) it takes at most a constant number of iterations α in expectation to draw r t to ln(λ) or less. According to Lemma 4.7 this ensures a drift of at least (1/4) min{1/2, √ λk/(8n)} ≥ (1/32) min{1, √ λk/n}, which implies an average drift of at least c min{1, √ λk/n} over all random rates at distance k, where c > 0 is a constant. Considering min{1, √ λk/n}, the minimum is taken on the first argument if k > n/ √ λ, and on the second if k < n/ √ λ. We are interested in the expected time to reduce the OneMax-value to at most n/λ. To ease the application of drift analysis, we artificially modify the process and make it create the optimum when the state (OneMax-value) is strictly less than n/λ. Clearly, the first hitting time of state at most n/λ does not change by this modification. Applying the variable drift theorem (Theorem 2.4) with x min = n/λ, X 0 = k ≤ n/ ln λ and h(x) = c min{1, √ λk/n}, the expected number of generations to reach state at most n/λ is bounded from above by 1) by assumption.

n/λ c √ λ(n/λ)/n + n/ √ λ n/λ n c √ λx dx + n/ ln λ n/ √ λ 1 c dx = O n √ λ + O n log λ √ λ + O n log λ , which is O(n/ log λ). The overall expected number of generations spent is O(log n + n/ log λ) = O(n/ log λ) since λ = n O(

The Near Region

In the near region, we have k ≤ n/λ. Hence, the fitness is so low that we can expect only a constant number of offspring to flip at least one of the remaining onebits. This assumes constant rate. However, higher rates are detrimental since they are more likely to destroy the zero-bits of the few individuals flipping one-bits. Hence, we expect the rate to drift towards constant values, as shown in the following lemma. Lemma 4.9. Let k ≤ n/λ, λ ≥ 45 and 4 ≤ r t ≤ ln(λ)/4. Then the probability that r t+1 = r t /2 is at least 0.5099. Proof. To prove the claim we exploit the fact that only few one-bits are flipped in both subpopulations. Using r := r t , we shall argue as follows. With sufficiently high (constant) probability, (i) the 2r-subpopulation contains no individual strictly better than the parent, that is, with fitness less than k, and (ii) all 2r-offspring with fitness at least k are identical to the parent. Conditional on this, either the r/2-population contains individuals with fitness less than k and the winning individual surely stems from this subpopulation, or the r/2-population contains no better offspring. In the latter case, we argue that there are many more individuals with fitness exactly k in the r/2-population than in the 2r-population, which gives a sufficiently high probability for taking the winning individual from this side (as it is chose uniformly at random from all offspring with fitness k).

Let N r/2 and N 2r be the number of offspring that did not flip any zero-bits using rate r/2 and 2r, respectively. Then

E(N r/2 ) = (λ/2)(1 -r/(2n)) n-k ≥ (1 - o(1))λe -r/2 /2, since k ≥ 1 and 1 - r 2n n-1 ≥ e -r 2 1 - r 2n r 2 -1 ≥ e -r 2 1 - c ln n 8n c ln n 8 -1 = (1 -o(1))e -r 2 ,
where we used that r ≤ ln λ/4 and λ = n O(1) , i. e. ln λ ≤ c ln n for some constant c.

Using k ≤ n/λ we get E(N 2r ) = (λ/2)(1 -2r/n) n-k ≤ (λ/2)e -2r(1-1/λ) .
Pr N 2r ≥ λe -2r(1-1 λ ) ≤ exp - 1 6 λ 1-1 2 (1-1 λ ) < 0.312.
Note that e -2r(1-1/λ) < e -r/2 /4 holds for all r ≥ 4 and λ ≥ 45. Since the offspring are generated independently, the events N r/2 > λe -r/2 /4 and N 2r < λe -2r(1-1 λ )

happen together with probability at least (1 -0.175) • (1 -0.312) ≥ 0.567 =: 1p err 1 .

Conditioning on this and by using a union bound the probability p err 2 that at least one of the N 2r offspring that do not flip any zero-bits flips at least one one-bit can be upper bounded by

p err 2 := N 2r • 2kr n ≤ 2re -2r(1-1 λ ) ≤ 0.004
using k/n ≤ 1/λ in the first and r ≥ 4 and λ ≥ 45 in the last inequality. By using a union bound, we find the probability p err 3 that at least one 2r-offspring flips exactly one one-bit and exactly one zero-bit to be at most

p err 3 := λ 2 2rk n 1 - 2r n k-1 2r(n -k) n 1 - 2r n n-k-1 ≤ 2r 2 1 - 2r n n-2
≤ (1 + o(1))2e 2(ln(r)-r) < (2 + o( 1))e -6 5 r < 0.017, for sufficiently large n, using k/n ≤ 1/λ for the first inequality. The third inequality is due to ln xx ≤ -(1e -1 )x < -(3/5)x for all x > 0 (see Lemma 2.14.a) and the last inequality stems from r ≥ 4. The second inequality follows from 1))e -2r , using again r ≤ ln λ ≤ c ln n for some constant c. Let M r be the number of such offspring. Any other fitness-decreasing flip-combinations of zeroes and ones in the 2r-subpopulation require an offspring to flip at least two one-bits. The probability that such an offspring is created is at most

1 - 2r n n-2 ≤ e -2r n (n-2) = e -2r(1-2 n ) = (1 + o(
p err 4 := λ 2 k 2 2r n 2 ≤ ln 2 λ 16λ < 0.021,
using k ≤ n/λ and r ≤ ln λ/4 and the fact that (ln 2 x)/x is decreasing for x ≥ e 2 and λ ≥ 45 > e 2 . The events N r/2 > λe -r/2 /4, N 2r < λe -2r(1-1 λ ) , M r = 0, and the event that no fitness-decreasing offspring is created in the 2r-subpopulation are sufficient to ensure that the best individual is either surely from the r/2-population or chosen uniformly at random from the N r/2 + N 2r offspring. Conditioning on these events, we have that the probability that the best offspring is chosen from the r/2-population is at least

N r/2 N r/2 + N 2r ≥ 1 1 + 4e -r(2(1-1 λ )-1 2 ) > 0.988.
Hence, using a union bound for the error probabilities, the unconditional probability is at least (1 -p err 1 -p err 2 -p err 3 -p err 4 ) • 0.988 + 1 2 2 > 0.5099.

We note that the restriction r t ≥ 4 in the lemma above is not strictly necessary. Also for smaller r t , the probability that the winning individual is chosen from the r t /2population is by an additive constant larger than 1/2. Showing this, however, would need additional proof arguments as for smaller r t , the event that both subpopulations contain individuals with fitness k -1 becomes more likely. We avoid this additional technicality by only arguing for r t ≥ 4, which is enough since any constant r t is sufficient for the fitness drift we need (since we do not aim at making the leading constant precise).

In the following proof of the analysis of the near region, we use the above lemma (with quite some additional arguments) to argue that the r-value quickly reaches 4 or less and from then on regularly returns to this region. This allows to argue that in the near region we have a speed-up of a factor of Θ(λ) compared to the (1+1) EA, since every offspring only has a probability of O(1/λ) of making progress (see also [START_REF] Doerr | Optimizing linear functions with the (1+λ) evolutionary algorithm -different asymptotic runtimes for different instances[END_REF][START_REF] Gießen | The interplay of population size and mutation probability in the (1+λ) EA on OneMax[END_REF]). Proof. The aim is to estimate the OneMax-drift at the points in time (generations) t where r t = O(1). To bound the expected number of generations until the mutation rate has entered this region, we basically consider the stochastic process Z t := max{0, log 2 (r t /a) }, where a := 4, which is the lower bound on r t from Lemma 4.9. However, as we do not have proved a drift of Z t towards smaller values in the region L := (ln λ)/4 ≤ r t ≤ 16 ln λ =: U (where 16 is an upper bound on c 2 (k) from Lemma 4.5), we use the potential function

X t (Z t ) :=        Z t if a ≤ r t ≤ L log 2 (L/a) + log 2 (rt/L) i=1 4 -i if L < r t < U log 2 (L/a) + log 2 (U /L)+1 i=1
4 -i + 4 -log 2 (U /L)-1 log 2 (r t /a) otherwise.
assuming that L and U have been rounded down and up to the closest power of 2, respectively. We note that X t ≥ log 2 (r t /a) -1 = log 2 (r t /(2a)) if r t ≤ L and X t ≥ (L/U ) 2 log 2 (r t /(2a)) in all three cases.

The potential function has a slope of 1 for a ≤ r t ≤ L. Lemma 4.9 gives us the drift E(X t -X t+1 | X t ; a ≤ r t ≤ L) ≥ (0.5099 -0.4901)/(2a) = Ω(1). The function satisfies X t (Z t ) -X t (Z t -1) ≥ 4(X t (Z t+1 ) -X t (Z t )) if L < r t < U , which corresponds to the region where the probability of decreasing r t by a factor of 1/2 has only be bounded from below by 1/4 due to the random steps. Still, E(X t -X t+1 | X t ; L < r t < U ) ≥ (1/4)4 -log 2 (U /L)-1 -(3/4)4 -log 2 (U /L) = Ω(1) in this region due to the concavity of the potential function. Finally, E(X t -X t+1 | X t ; r t ≥ U ) = 4 -log 2 (U /L)-1 (1/(2a))Ω(1) = Ω(1) by Lemma 4.5. Hence, altogether E(X t -X t+1 | X t ; r t ≥ a) ≥ κ for some constant κ > 0. As X 0 = O(log n), additive drift analysis yields an expected number of O(log n) generations until for the first time X t = 0 holds, corresponding to r t ≤ a. We denote this hitting time by T .

We now consider an arbitrary point of time t ≥ T . The aim is to show a drift on the OneMax-value, depending on the current OneMax-value Y t , which satisfies Y t ≤ n/λ with probability 1. To this end, we will use Lemma 2.11. We choose b large enough such that 2e -2b•κ/4 ≤ 1δ holds for some positive constant δ > 0 and note that b is constant. We consider two cases. If X t ≤ b, which happens with probability at least δ according to the lemma, then the bound X t ≥ (L/U ) 2 (log 2 (r t /(2a))) implies r t ≤ 2 (U /L) 2 2a2 b . Hence, we have r t = O(1) in this case and obtain a probability of at least

1 -1 - Y t 1 2r t n 1 - 2r t n n-1 λ ≥ 1 -1 -Θ Y t n λ = Ω(λY t /n)
to improve the OneMax-value by 1, using that Y t = O(n/λ) and pessimistically assuming a rate of 2r t in all offspring. If X t > b, we bound the improvement from below by 0. Using the law of total probability, we obtain

E(Y t -Y t+1 | Y t ; Y t ≤ n/λ) = δΩ(λY t /n) = Ω(λY t /n).
Now a multiplicative drift analysis with respect to the stochastic process on the Y t , more precisely Theorem 2.3 using δ = Θ(λ/n) and minimum state 1, gives an expected number of O((n/λ) log Y 0 ) = O(n log(n)/λ) generations until the optimum is found. Together with the expected number O(log n) until the r-value becomes at most a, this proves the theorem.

Putting Everything Together

In this section, we put together the analyses of the different regimes to prove our main result.

Proof of Theorem 4.1. The lower bound actually holds for all unbiased parallel blackbox algorithms, as shown in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF].

We add up the bounds on the expected number of generations spent in the three regimes, more precisely we add up the bounds from Theorem 4.6, Theorem 4.8 and Theorem 4.10, which gives us O(n/ log λ + n log(n)/λ + log n) generations. Due to our assumption λ = n O(1) the bound is dominated by O(n/ log λ + n log(n)/λ) as suggested.

Proof of Lemma 4.2. We basically revisit the regions of different OneMax-values analyzed in this chapter and bound the time spent in these regions under the assumption r = ln(λ)/2. In the far region, Lemmas 4.4 and 4.5, applied with this value of r, imply a fitness drift of Ω(log(λ)/ log(en/k)) per generation, so the expected number of generations spent in the far region is O(n/ log λ) as computed by variable drift analysis in the proof of Theorem 4.6.

The middle region is shortened at the lower end. For k ≥ n/ √ λ, Lemma 4.7 gives a fitness drift of Ω(1), implying by additive drift analysis O(n/ log λ) generations to reduce the fitness to at most n/ √ λ. In the near region, which now starts at n/ √ λ, we have to argue slightly differently. Note that every offspring has a probability of at least (1r) n ≥ e -ln(λ)/2+O(1) = Ω(λ -1/2 ) of not flipping a zero-bit. Hence, we expect Ω( √ λ) such offspring. We pessimistically assume that the other individuals do not yield a fitness improvement; conceptually, this reduces the population size to Ω( √ λ) offspring, all of which are guaranteed not to flip a zero-bit. Adapting the arguments from the proof of Theorem 4.10, the probability that at least of one of these individuals flips at least a one-bit is at least

1 -1 - Y t 1 r t n Ω( √ λ) ≥ 1 -1 -Θ Y t n Ω( √ λ) = Ω( √ λY t /n),
which is a lower bound on the fitness drift. Using the multiplicative drift analysis, the expected number of generations in the near region is O(n log(n)/ √ λ). Putting the times for the regions together, we obtain the lemma.

Experimental Results

Since our analysis is asymptotic in nature we performed some elementary experiments in order to see whether besides the asymptotic runtime improvement (showing an improvement for an unspecified large problem size n) we also see an improvement for realistic problem sizes. For this purpose we implemented the (1+λ) EA in C using the GNU Scientific Library (GSL) for the generation of pseudo-random numbers. In this section our performance measure is the runtime, represented by the number of generations until the optimum is found for the first time.

The first plot in Figure 4.1 displays the average runtime over 10000 runs of the self-adjusting (1+λ) EA on OneMax for n = 5000 as given in Algorithm 8 over λ = 100, 200, . . . , 1000; the second plot shows the corresponding interquartile ranges to support that the results are statistically significant. We set the initial mutation rate to 2, i. e., the minimum mutation rate the algorithm can attain. Moreover, the plot displays the average runtimes of the classic (1+λ) EA using static mutation probabilities of 1/n and of (ln λ)/(2n), the latter of which is asymptotically optimal for large λ according to Lemma 4.2.

The average runtimes of both algorithms profit from higher offspring population sizes λ leading to lower average runtimes as λ increases. Interestingly, the two static settings of the classic (1+λ) EA outperform the self-adjusting (1+λ) EA for small values of λ up to λ = 400. For higher offspring population sizes the self-adjusting (1+λ) EA outperforms the classic ones, indicating that the theoretical performance gain of ln ln λ can in fact be relevant in practice. Furthermore, we implemented the self-adjusting (1+λ) EA without the random steps, that is, when the rate is always adjusted according to how the best offspring are distributed over the two subpopulations. The experiments show that this variant of the self-adjusting (1+λ) EA performs generally slightly better on OneMax. Since the OneMax fitness landscape is structurally very simple, this result is not totally surprising. It seems very natural that the fitness of the best of λ/2 individuals, viewed as a function in the rate, is a unimodal function. In this case, the advantage of random steps to be able to leave local optima of this function is not needed. On the other hand, of course, this observation suggests to try to prove our performance bound rigorously also for the case without random rate adjustments. We currently do not see how to do this. Lastly, we implemented the (1+λ) EA using the fitness-depending mutation rate p = max{ ln λ n ln(en/d) , 1 n } as presented in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF]. The experiments suggest that this scheme outperforms all other variants considered. Additionally we implemented another variant of the self-adjusting (1+λ) EA using three equally-sized subpopulations i. e. the additional one is using (that is, exploiting) the current mutation rate. We compared this variant with the self-adjusting (1+λ) EA, both with and without using random steps. The results are shown in Figure 4.2, again with respect to average runtimes and interquartile ranges. The experiments suggest that the variant using three subpopulations outperforms the self-adjusting (1+λ) EA slightly for small population sizes. For very high population sizes, using just two subpopulations seems to be a better choice.

To gain some understanding on how the parameters influence the runtime, we implemented the self-adjusting (1+λ) EA using different mutation rate update factors, that is, we consider the self-adjusting (1+λ) EA as given in Algorithm 8 where the mutation rate r t is increased or decreased by some factor F (instead of the choice F = 2 made in Algorithm 8). Note that we do not change the rule that we use the rates r/2 and 2r to create the subpopulations. Furthermore, after initialization, the algorithm starts with rate F and the rate is capped below by F and above by 1/(2F ) during the run, accordingly.

The results are shown in Figure 4.3. The plot displays the average runtime over 10000 runs of the self-adjusting (1+λ) EA on OneMax for n = 5000 over λ = 100, 200, . . . , 1000 using the update factors F = 2.0, 1.5, 1.01. The plot suggests that lower values of F yield a better performance. This result is not immediately obvious. Clearly, a large factor F implies that the rate changes a lot from generation to generation (namely by a factor of F ). These changes prevent the algorithm from using a very good rate for several iterations in a row. On the other hand, a small value for F implies that it takes longer to adjust the rate to value that is far from the current one. We also performed experiments for F > 2 and observed even worse runtimes than for F = 2.0. The figure does not display the outcomes of these additional experiments since this would impair the readability of the diagram.

Finally, to illustrate the nontrivial development of the rate during a run of the algorithm we plotted the rate of three single runs of the self-adjusting (1+λ) EA using different factors F over the fitness in Figure 4.4. Since the algorithm initialized with the rate F , the rate increases after initialization and decreases again with decreasing fitness-distance to the optimum. The plot suggests that for higher values of F the rate is more unsteady due to the greater impact of the rate adjustments while smaller rate updates yield a more stable development of the rate. Interestingly, for all three values of F , the rates seem to correspond to the same rate after the initial increasing phase from F . Note that this illustration does not indicate the actual runtime. In fact, the specific runtimes are 19766 for F = 1.01, 19085 for F = 1.05 and 19857 for F = 1.1. A similar, more pronounced behaviour can be seen for F = 2.0; we chose these particular values of F for illustrative purposes since for F = 2.0 the variance in the rate can be visually confusing for the reasons given above.

While we would draw from this experiment the conclusion that a smaller choice of F is preferable in a practical application of our algorithm, the influence of the parameter on the runtime is not very large. So it might not be worth optimizing it and rather view Algorithm 8 as a parameter-less algorithm. Self-adapting (1,λ) EA

In this chapter we propose a version of the (1, λ) evolutionary algorithm (EA) with a natural self-adaptive choice of the mutation rate and prove that it optimizes the classic OneMax benchmark problem in a runtime that is asymptotically optimal among all λ-parallel black-box optimization algorithms and that is, for λ ≥ C ln n with a large enough constant C and λ = n O(1) , better than the runtimes of the (1,λ) EA and the (1 + λ) EA for all static choices of the mutation rate. It obviously cannot beat the (also asymptotically optimal) runtimes of the (1 + λ) EA with fitness-dependent mutation rate of Badkobeh, Lehre, and Sudholt [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] and of the (1 + λ) EA with self-adjusting (exogenous) mutation rate we proposed in Chapter 4. Hence the good news of our result is that this optimal runtime could be obtained in a generic manner. Note that both the fitness-dependent mutation rate of [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] and the self-adjusting rate of Chapter 4 with its mix of random and greedy rate adjustments would have been hard to find without a deeper understanding of the mathematics of these algorithms.

Not surprisingly, the proof of our main result has some similarity to the analysis of the self-adjusting (1 + λ) EA of Chapter 4. In particular, we also estimate the expected progress in one iteration and use variable drift analysis. Also, we need a careful probabilistic analysis of the progress obtained from different mutation rates to estimate which rate is encoded in the new parent individual (unfortunately, we cannot reuse the analysis of Chapter 4 since it is not always strong enough for our purposes). The reason, and this is also the main technical challenge in this work, is that the (1,λ) EA can lose fitness in one iteration. This happens almost surely when the mutation rate is too high. For this reason, we need to argue more carefully that such events do not happen regularly. To do so, among several new arguments, we also need a stronger version of the occupation probability result [KLW15, Theorem 7] since (i) we need sharper probability estimates for the case that movements away from the target are highly unlikely and (ii) for our process, the changes per time step cannot be bounded by a small constant. Note that for the (1 + λ) EA, an excursion into unfavorable rate regions is less a problem as long as one can show that the mutation rate returns into the good region after a reasonable time. The fact that the (1,λ) EA can lose fitness also makes it more difficult to cut the analysis into regimes defined by fitness levels since it is now possible that the EA returns into a previous regime. In this work, we also gained two insights which might be useful in the design of future self-adaptive algorithms.

Need for non-elitism: Given the previous works, it would be natural to try a selfadaptive version of the (1 + λ) EA. However, this is risky. While the self-adjusting EA of Chapter 4 can cope with the fact that the current mutation rate is far from the ideal one and in this case provably quickly changes the rate to an efficient setting, a selfadaptive algorithm cannot do so. Since the mutation rate is encoded in the individual, a change of the rate can only occur if an offspring is accepted. For an elitist algorithm like the (1 + λ) EA, this is only possible when an offspring is generated that is good enough to compete with the parent(s). Consequently, if the parent individual in a self-adaptive (1 + λ) EA has a high fitness, but a detrimental (that is, large) mutation rate, then the algorithm is stuck with this individual for a long time. Already for the simple OneMax function, such a situation can lead to an exponential runtime. Needless to say, when using a comma strategy we have to choose λ sufficiently large to avoid losing the current-best solution too quickly; see [START_REF] Rowe | The choice of the offspring population size in the (1, λ) evolutionary algorithm[END_REF] for a precise analysis of this phenomenon for the (1,λ) EA using a static mutation rate of 1/n. Tie-breaking towards lower mutation rates: To prove our result, we need that the algorithm in case of many offspring of equal fitness prefers those with the smaller mutation rate. Given that the usual recommendation for the mutation rate is small, namely 1 n , and that it is well-known that large rates can be very detrimental, it is natural to prefer smaller rates in case of ties (where, loosely speaking, the offspring population gives not hint which rate is preferable). This choice is similar to the classic tie-breaking rule of preferring offspring over parents in case of equal fitness (again, the fitness indicates no preference, but the simple fact that one is maybe working already for quite some time with this parent suggest to rather prefer the new individual). Without proof, we remark that without this tie-breaking rule we would need λ = n Ω(1) to ensure a positive drift towards the optimum throughout the process.

The main result of this work Theorem 5.1 is a mathematical runtime analysis of the performance of the algorithm proposed above on the classic benchmark function OneMax : {0, 1} n → R defined by OneMax(x) = n i=1 x i for all x = (x 1 , . . . , x n ) ∈ {0, 1} n . Since such runtime analyses are by now a well-established way of understanding the performance of evolutionary algorithms, we only briefly give the most important details and refer the reader to the textbook [START_REF] Jansen | Analyzing Evolutionary Algorithms -The Computer Science Perspective[END_REF].

Our main result is as follows. The aim of runtime analysis is predicting how long an evolutionary algorithm takes to find the optimum or a solution of sufficient quality. As implementation-independent performance measure usually the number of fitness evaluations performed in a run of the algorithm is taken. More precisely, the optimization time of an algorithm on some problem is the number of fitness evaluations performed until for the first time an optimal solution is evaluated. Obviously, for a (1,λ) EA, the optimization time is essentially λ times the number of iterations performed until an optimum is generated.

As in classic algorithms analysis, our main goal is an asymptotic understanding of how the optimization time depends on the problems size n. Hence all asymptotic notation in the chapter will be with respect to n tending to infinity.

The proof of the theorem is based on a careful, technically demanding drift analysis of both the current OneMax-value k t (which is also the fitness distance, recall that our goal is the minimization of the objective function) and the current rate r t of the parent. In very rough terms, a similar division of the run as in Chapter 4 into regions of large OneMax-value, the far region (Section 5.2), and of small OneMax-value, the near region (Section 5.3) is made. The middle region considered in Chapter 4 is subsumed under the far region here.

In the remaining of our analysis, we regard n sufficiently large, λ ≥ C ln n with a large constant C, and λ = n O(1) .

Algorithm

We propose a (1,λ) EA with self-adaptive mutation rate for the minimization of pseudo-boolean functions f : {0, 1} n → R as defined in Algorithm 9.

To encode the mutation rate into the individual, we extend the individual representation by adding the rate parameter. Hence the extended individuals are pairs (x, r) consisting of a search point x ∈ {0, 1} n and the rate parameter r, which shall indicate that r/n is the mutation rate this individual was created with.

The extended mutation operator first changes the rate to either r/F or F r with equal probability (F > 1). It then performs standard bit mutation with the new rate.

In the selection step, we choose from the offspring population an individual with best fitness. If there are several such individuals, we prefer individuals having the smaller rate r/F , breaking still existing ties randomly. In this winning individual, we replace the rate by F if it was smaller and by n/(2F ) if it was larger.

We formulate the algorithm to start with an initial mutation rate r init , which we require to be in [F, n/(2F )]. For the result we shall show in this work, the initial rate is not important, but without this prior knowledge we would strongly recommend to start with the smallest possible rate r init = F . Due to the multiplicative rate adaptation, the rate can quickly grow if this is profitable. On the other hand, a too large initial rate might lead to an erratic initial behavior of the algorithm. For the adaptation parameter, we shall use F = 32 in our runtime analysis. Having such a large adaptation parameter eases the already technical analysis, because now the two competing rates r/F and F r are different enough to lead to a significantly different performance. For a practical application, we suspect that a smaller value of F is preferable as it leads to a more stable optimization process. The choice of the offspring population size depends mostly on the degree of parallelism one wants to obtain. Clearly, λ should be at least logarithmic in n to prevent a too quick loss of the current-best solution. For our theoretical analysis, we require λ ≥ C ln n for a sufficiently large constant C.

Algorithm 9

The (1,λ) EA with self-adapting mutation rate, adaptation parameter F > 1, and initial mutation rate r init /n such that r init ∈ [F, n/(2F )] and r init = F i for some i ∈ N.

Select x 0 uniformly at random from {0, 1} n . Set r 0 ← r init .

for t ← 1, 2, . . . do for i ← 1, . . . , λ do Choose r t,i ∈ {r t-1 /F, F r t-1 } uniformly at random. Create x t,i by flipping each bit in x independently with probability r t,i /n.

Choose i ∈ [1..λ] such that f (x t,i ) = min j∈[1.
.λ] f (x t,j ); in case of a tie, prefer an i with r t,i = r t-1 /F ; break remaining ties randomly.

(x t , r t ) ← (x t,i , r t,i ). Replace r t with min{max{F, r t }, n/(2F )}.

The Far Region

In this section, we analyze the optimization behavior of our self-adaptive (1,λ) EA in the regime where the fitness distance k is at least n/λ. Due to our assumption λ ≥ C ln n, it is very likely to have at least one copy of the parent among λ offspring for r = O(ln λ). Thus the (1,λ) EA works almost the same as the (1 + λ) EA but can lose fitness with small probability. The following lemma is crucial in order to analyze the drift of the rate depending on k, which follows a similar scheme as with the (1 + λ) EA proposed in [START_REF] Doerr | The (1+λ) Evolutionary Algorithm with Self-Adjusting Mutation Rate[END_REF].

Roughly speaking, the rate leading to optimal fitness progress is n for k ≥ n/2 + ω( n ln(λ)), n/2 for k = n/2 ± o( n log(λ)), and then the optimal rate quickly drops to r = Θ(log λ) when k ≤ n/2εn.

To ease the representation, we first define two fitness dependent bounds L(k) and R(k).

Definition 5.2. Let n/ ln λ < k < n/2 and F = 32. We define L(k) := (F ln(en/k)) -1 and U (k

) := n(2n -k)/(22(n -2k) 2 ).
According to the definition, both L(k) and R(k) monotonically increase when k increases.

Lemma 5.3. Let F = 32. Consider an iteration of the self-adaptive (1,λ) EA with current fitness distance k and current rate r.

Then:

1. If n/ ln λ < k and F ≤ r ≤ L(k) ln λ, the probability that all best offspring have been created with rate F r is at least 1 -O(ln 3 (λ)/λ 1/(4 ln ln λ) ).

2. If k < n/2 and n/(2F ) ≥ r ≥ U (k) ln λ, then the probability that all best offspring have been created with rate r/F is at least 1λ 1-(23/22)r/(U (k) ln λ) .

Proof of Lemma 5.3 part 1. Let q(k, i, r) and Q(k, i, r) be the probability that standard bit mutation with mutation rate p = r/n creates from a parent with fitness distance k an offspring with fitness distance exactly ki and at most ki, respectively. Then

q(k, i, r) = k-i j=0 k i + j n -k j p i+2j (1 -p) n-i-2j
(5.1) and Q(k, i, r) = k j=i q(k, j, r). We aim at finding i such that Q(k, i, F r) ≥ ln(λ)/λ while Q(k, i, r/F ) = O(ln 3 (λ)/λ 1+1/4(ln ln λ) ). Then we use these to bound the probability that at least one offspring using rate F r obtains a progress of i or more while at the same time all offspring using rate r/F obtains less than i progress. Let i * be the largest i such that Q(k, i, F r) ≥ ln(λ)/λ. Using the fact that ln(1x) ≥ -xx 2 for all 0 < x < 2/3, we notice that (1 1))e -F r . We also notice that

-F p) n-i ≥ (1 -F p) n ≥ e -F r-(F r) 2 /n . By the assumption that r ≤ L(k) ln λ ≤ ln λ, we obtain (F r) 2 /n = O(ln 2 λ/n) = o(1). Thus (1 -F p) n-i = (1 -o(
( k i ) = (k/i)((k -1)/(i - 1)) • • • (k -i + 1) > (k/i) i-1 (k -i) = (k/i) i ((k -i)i/k) > 2(k/i) i for 2 < i < k -2. Thus for i > 2 we can bound Q(k, i, F r) by Q(k, i, F r) ≥ q(k, i, F r) ≥ k i (F p) i (1 -F p) n-i ≥ k i • F r n i e -F r .
(5.2)

Let i = max{(F -1)r, ln λ/(8 ln ln λ)}. We prove i * ≥ i by distinguishing between two cases according to which argument maximizes i.

If i = ln λ/(8 ln ln λ), then r ≤ i/(F -1) and F r ≤ 2i. Referring to inequality (5.2) and using the fact that k/n ≥ 1/ ln λ, i < ln λ, and ln ln(λ) > 1, we obtain ln

(Q(k, i, F r)) ≥ i ln k in -F r ≥ -i ln(ln 2 λ) -2i = -2i ln ln λ -2i > -4i ln ln λ = - ln λ 2 ≥ ln ln λ λ and thus Q(k, i, F r) ≥ ln(λ)/λ. If i = (F -1)r, then r ≥ ln λ/(8(F -1) ln ln λ) since F is a constant. Using r ≤ L(k) ln λ, we obtain ln λ ≥ ln(en/k)F r which is equivalent to (k/en) F r ≥ 1/λ. Furthermore, (k/n) i > (k/n) F r since i = (F -1)r < F r. Thus Q(k, i, F r) ≥ k i • F r n i e -F r ≥ F F -1 (F -1)r k en F r ≥ 2 r k en F r ≥ ln λ λ .
Since Q(k, i, r) is decreasing in i, we obtain i * ≥ max{(F -1)r, ln λ/(8 ln ln λ)}.

Using a Chernoff bound and recalling that the expected number of flipped bits is bounded by F L(k) ln λ ≤ ln λ/ ln(2e), we notice that i * ≤ ln λ. This upper bound will be used to estimate Q(k, i * , F r)/Q(k, i * + 1, F r) in the following part of the proof.

We now prove that Q(k, i * , r/F ) = o(1/λ). By comparing each component in q(k, i, r/F ) and q(k, i, F r), and applying Lemma 2.14 3 to estimate (1

-F r/n) n and (1 -r/(F n)) n with r = O(ln λ) = o(n 1/2 ) for large enough n, we obtain q(k, i, F r) q(k, i, r/F ) ≥ F 2i (1 -F r/n) n (1 -r/(F n)) n ≥ 1 -o(1) F 2i e -(F -1/F )r > F 2i e -F r . Therefore Q(k, i * , F r)/Q(k, i * , r/F ) ≥ F 2i * e -F r = exp(2i * ln F -F r) ≥ exp(2i * ln F -F i * /(F -1)) > exp(3i * ) > λ 1/(4 ln ln λ)
, where in the first inequality, we use the fact that i * ≥ (F -1)r. To prove Q(k, i * , r/F ) = O(ln 3 (λ)/λ 1+1/4(ln ln λ) ),

we first show Q(k, i * , F r)/Q(k, i * + 1, F r) = O(ln 2 λ).
Then we use this to bound

Q(k, i * , F r) = O(ln 3 (λ)/λ) according to the definition of i * . Finally we obtain Q(k, i * , r/F ) ≤ Q(k, i * , F r)/λ 1/(4 ln ln λ) = O(ln 3 (λ)/λ 1+1/4(ln ln λ) ). It remains to bound Q(k, i * , F r)/Q(k, i * + 1, F r).
We show that the majority of q(k, i, r) are from the first 3r terms in the summation of equation (5.1). Let q(k, i, r) j denote the j-th

item ( k i+j )( n-k j )p i+2j (1 -p) n-i-2j in equation (5.1). Then q(k, i, r) j+1 q(k, i, r) j = k -i -j i + j + 1 • n -k -j j + 1 • p 2 • (1 -p) -2 ≤ r 2 (i + j + 1)(j + 1)
.

If j > 3r, then r 2 /((i + j + 1)(j + 1)) < 1/9, and thus

q(k, i, r) ≤   3r j=0 q(k, i, r) j   + q(k, i, r) 3r   k-i j=3r+1 (1/9) j-3r   ≤   3r j=0 q(k, i, r) j   + q(k, i, r) 3r • 1/9 1 -1/9 =   3r-1 j=0 q(k, i, r) j   + 9 8 • q(k, i, r) 3r ≤ 9 8 3r j=0 q(k, i, r) j .
We notice that

q(k, i + 1, r) j q(k, i, r) j = ( k i+j+1 )( n-k j )p i+2j+1 (1 -p) n-i-2j-1 ( k i+j )( n-k j )p i+2j (1 -p) n-i-2j = (k -i -j)p (i + j + 1)(1 -p) ,
using the fact that 3r j=0 q(k, i, r) j ≤ q(k, i, r) ≤ (9/8) 3r j=0 q(k, i, r) j for all (k, i, r), we compute

q(k, i * + 1, F r) q(k, i * , F r) ≥ 3F r j=0 q(k, i * + 1, F r) j (9/8) 3F r j=0 q(k, i * , F r) j ≥ 8 9 • k -i * -3F r i * + 3F r + 1 • p 1 -p . Since i * ≥ (F -1)r, i * ≤ ln λ, and k ≥ n/ ln λ = ω(ln λ), we obtain q(k, i * + 1, F r) q(k, i * , F r) = Ω kp i * = Ω kr i * n = Ω 1 ln 2 λ . Consequently we have q(k, i * , F r)/Q(k, i * + 1, F r) ≤ q(k, i * , F r)/q(k, i * + 1, F r) = O(ln 2 λ) and Q(k, i * , F r) Q(k, i * + 1, F r) = 1 + q(k, i * , F r) Q(k, i * + 1, F r) = O(ln 2 λ).
So finally Q(k, i * , F r) = O(ln 3 (λ)/λ) due to the definition of i * , and

Q(k, i * , r/F ) ≤ Q(k, i * , F r) F 2i * e -F r = O ln 3 λ λ • λ 1/(4 ln ln λ) .
A simple union bound shows that with probability 1 -O(ln 3 (λ)/λ 1/(4 ln ln λ) ), no offspring of rate r/F manages to obtain a progress of i * or more. However, the probability that an offspring has rate F r and obtains at least i * progress is ln(λ)/(2λ). Thus the probability that no offspring generated with rate F r achieves a progress of at least i * is at most (1 -ln(λ)/(2λ)) λ ≤ λ -1/2 = o(ln 3 (λ)/λ 1/(4 ln ln λ) ). This proves the first statement of the lemma.

Proof of Lemma 5.3 part 2. For r ∈ {r/F, F r} let the random variable X(k, r) denote the number of flipped bits in k ones and Y (k, r) denote the number of flipped bits in nk zeros when applying standard bit mutation with probability p = r/n. Let Z(k, r) := Y (k, r) -X(k, r) denote the improvement in fitness. Let Z * (k, r) denote the minimal Z(k, r) among all offspring which apply rate r.

E(Z(k, r)) = (n -k) r/n -k r/n = (n -2k) r/n. Our aim is to find a β such that Pr (Z(k, r/F ) ≤ β) = Θ(1) while Pr (Z(k, F r) ≤ β) = o(1/λ),
(Z * (k, r/F ) < Z * (k, F r)). Let β := E(Z(k, r/F )). We notice that Pr(X(k, r/F ) > E(X(k, r/F )) -1) ≥ 1/2 since the median of binomial distribution X(k, r/F ) is E(X(k, r/F ) or E(X(k, r/F ) . Applying Lemma 2.16 to Pr(Y (k, r/F ) < E(Y (k, r/F )) -1) with E(Y (k, r/F )) = Ω(ln λ) = ω(1) by assumption r ≥ U (k) ln λ and E(Y (k, r/F )) < (n -k)/2, we obtain for n sufficiently large that Pr Y (k, r/F ) < E(Y (k, r/F )) -1 ≥ 1 2 - n -k 2π (n -k)p (n -k -(n -k)p ) > 2 5 .
(5.3) Thus Pr(Z(k, r/F ) ≤ β) > (1/2)(2/5) = 1/5. We use Bernstein's inequality (version Lemma 5.7) to bound Pr (Z(k, F r) ≤ β) and obtain

Pr Z(k, F r) ≤ E(Z(k, F r)) -∆ ≤ exp - ∆ 2 2(Var(Z(k, F r)) + ∆/3) for all ∆ > 0. With ∆ = E(Z(k, F r)) -β = (n -2k)(F r/n -r/(F n)) = (n -2k)(F 2 -1)r/(F n) and Var(Z(k, F r)) = F r(1 -F r/n) < F r, we compute P r Z(k, F r) ≤ β ≤ exp - 1 2 • (F 2 -1) 2 (n -2k) 2 r 2 F 2 n 2 (F r + (n -2k)(F 2 -1)r/(3F n)) = exp - 1 2 • (F 2 -1) 2 (n -2k) 2 r F 3 n 2 + F n(n -2k)(F 2 -1)/3 ≤ exp - 3 2 • (F 2 -1) 2 (n -2k) 2 r 3F 3 n 2 + F 3 n(n -2k) = exp - 3 4 • (F 2 -1) 2 (n -2k) 2 r F 3 n(2n -k) . Given F = 32 and r ≥ U (k) ln λ then Pr Z(k, F r) ≤ β < exp - 23.9(n -2k) 2 r n(2n -k) < λ -23.9r 22U (k) ln λ .
With a simple union bound, we obtain Pr(Z

* (k, F r) ≤ β) < λ Pr(Z(k, F r) ≤ β) < λ 1-23.9r/(22U (k) ln λ)
. The probability that an offspring has rate r/F and obtains β is at least (1/2)(1/5) = 1/10. Thus the probability that no offspring generated with r/F has a Z-value of at least

β is at most (1 -1/10) λ = exp(-Θ(λ)). Therefore Pr(Z * (k, F r) < Z * (k, r/F )) < λ 1-23.9r/(22U (k) ln λ) (1 -exp(-Θ(λ))) = o(λ 1-23r/(22U (k) ln λ)
), which means with probability at least 1λ 1-(23r/(22U (k) ln λ) all best offspring have been created with rate r/F . Lemma 5.3 will be crucial in order to bound the expected progress on fitness in the far region. We notice that ln λ = o( √ n) in the lemma we may allow r > ln λ when k is large and r = Θ(n) when k = n/2 -Θ( √ n ln λ). It is easy to show a positive progress on fitness for r < ln λ since there will be sufficiently many offspring that do not flip zeroes. When r ≥ ln λ we expect all offspring to flip zeros, but we can still show a positive drift when k > 7n/20, as stated in the following lemma. The idea is that the standard variation of the number of flipping ones is kr/n(1r/n) = Θ( √ r). This makes a deviation compensating bad flips among the remaining n -2k zeros likely enough.

Lemma 5.4. Let 7n/20 ≤ k < n/2, F = 32 and α = 10 -4 . Assume r ≤ min{n 2 ln λ/(12(n -2k) 2 ), n/(2F )}. Assume that from a parent with fitness distance k we generate an offspring using standard bit mutation with mutation rate p = r/n. Then the probability that this offspring has a fitness distance of at most ks with s := α(min{ln λ, r} + (n -2k)r/n), is at least λ -0.98 .

Proof. We first look at the case when r < 1/(2α). In this case s ≤ α(r + (n -2k)r/n) ≤ α(2r) < 1. Then the probability that this offspring has a fitness distance of k -1 > ks is at least

k 1 r n 1 1 - r n n-1 = Θ(e -r ) = ω(λ -0.98 ).
Therefore it remains to consider r ≥ 1/(2α). Let random variables X and Y denote the number of flips in k one-bits and (nk) zero-bits, respectively, in an offspring using rate p = r/n. Then X -Y is the decrease of fitness distance. X and Y follow binomial distributions Bin(k, p) and Bin(nk, p), respectively. Let

B(x) := Pr(X = x) = k x p x (1 -p) k-x for all x ∈ {0, 1, . . . , k}, F (x) := Pr(X ≥ x) = k i= x B(i) for all x ∈ [0, k].
Since r ≥ 1/(2α) ≥ 5000 and n ≤ 20k/7, then p = r/n ≥ 5000 • 7/(20k) = 1750/k. Using this and the fact that p ≤ 1/(2F ), we apply Lemma 2.16 and obtain

Pr(X > E(X)) > 1 2 - k 2π kp (k -kp ) > 1 2 - 1 2kp > 2 5 Similarly Pr(Y ≤ E(Y )) = 2/5. Since E(X -Y ) = kp -(n -k)p = -(n -2k)p, we bound Pr X -Y ≥ s ≥ Pr X ≥ E(X) + (n -2k)p + s Pr Y ≤ E(Y ) ≥ 2 5 F kp + (n -2k)p + s .
Let δ := (n -2k)p + s , u := kp and ũ := u . We notice that u = rk/n ≥

(1/(2α))(7/20) = 1750. Furthermore, we have

δ < ũ -2 < u since δ = (n -2k)p + s < (1 + α)(n -2k)p + α min{ln λ, r} + 1 ≤ (1 + α) n -2k n r + αr + 1 ≤ (1 + α) 3 10 + α r + 1 = 3 + 13α 10 • n k • u + 1 < 3 + 13α 10 (3u) + 1 < 0.91u + 1 = u -0.09u + 1 ≤ u -(0.09 • 1750 -1) = u -156.5.
We aim at proving F (u + δ) = ω(λ -0.98 ) to obtain this lemma. If F (u + δ) = Θ(1) then the conclusion holds. It remains to consider F (u + δ) = o(1) while F (u) -F (u + δ) ≥ 2/5o(1) as stated in equation (5.3). For any x ∈ Z ≥u we have

B(x + 1) B(x) = k -x x + 1 • p 1 -p ≤ u -up u -up + 1 -p < 1. Since ũ = u then B( ũ) > B( ũ + 1) > • • • > B(k)
, and thus F (u + δ) ≥ δB( ũ + 2δ) as well as F (u) -F (u + δ) ≤ δB( ũ). Using the fact that p/(1p) = u/(ku) and ũ -1 < u, we see that

B( ũ + 2δ) B( ũ) = (k -ũ) • • • (k -( ũ + 2δ) + 1) ( ũ + 1) • • • ( ũ + 2δ) • p 2δ (1 -p) 2δ ≥ (k -( ũ -1) -2δ) 2δ ( ũ + 1) • • • ( ũ + 2δ) • u 2δ (k -u) 2δ ≥ 1 - 2δ k -u 2δ u 2δ ( ũ + 1) • • • ( ũ + 2δ) .
We compute the following factorials using Robbins's Stirling's approximation in [START_REF] Robbins | A Remark on Stirling's Formula[END_REF] (

ũ + 2δ)! ≤ 2π( ũ + 2δ) ũ + 2δ e ũ+2δ exp 1 12( ũ + 2δ) , ũ! ≥ √ 2π ũ ũ e ũ exp 1 12 ũ + 1 .
Notice that 12 ũ + 1 < 12( ũ + 2δ), we obtain 1

( ũ + 1) • • • ( ũ + 2δ) = ũ! ( ũ + 2δ)! ≥ ũ ũ + 2δ ũ ũe 2δ ( ũ + 2δ) ũ+2δ ≥ ũ ũ + 2δ u ũe 2δ ( ũ + 2δ) ũ+2δ . Therefore B( ũ + 2δ) B( ũ) ≥ 1 - 2δ k -u 2δ ũ ũ + 2δ u ũ+2δ e 2δ ( ũ + 2δ) ũ+2δ = ũ ũ + 2δ exp 2δ ln 1 - 2δ k -u + ( ũ + 2δ) ln u ũ + 2δ + 2δ ≥ ũ ũ + 2δ exp 2δ ln 1 - 2δ k -u + ( ũ + 2δ) ln 1 - 2δ + 1 ũ + 2δ + 2δ . We notice that 2δ/(k -u) ≤ 2δ/(2F u -u) = 2δ/(63u) < 2/63 < 1/2 and (2δ + 1)/( ũ + 2δ) < (2δ + 1)/(3δ + 2) < 2/3. Referring to Lemma 2.14 3, 4, we compute 2δ ln 1 - 2δ k -u ≥ - 3 2 • 4δ 2 k -u = - 6δ 2 u/p -u ≥ - 6δ 2 2F u -u ≥ - δ 2 10u , ( ũ + 2δ) ln 1 - 2δ + 1 ũ + 2δ ≥ -(2δ + 1) - (2δ + 1) 2 ũ + 2δ ≥ -2δ - 4δ 2 u -3, B( ũ + 2δ) B( ũ) ≥ ũ ũ + 2δ exp - 41δ 2 10u -3 ≥ 1 3 e -3 exp - 41δ 2 10u .
(5.4) Proof. The probability of using rate r/F is 1/2. Thus with probability at least 1 -(1/2) λ = 1o(1/n 3 ), at least one offspring uses rate r/F . For this offspring, the expected loss is (n -2k)r/(F n). If the complementary event (hereinafter called failure) of probability o(1/n 3 ) happens, we estimate ∆(k, r) pessimistically by -n. This proves the first statement.

To prove the second item, we take i = 10 -4 ((n -2k)r/(F n) + min{ln λ, r/F }). According to Lemma 5.4, the probability that an offspring uses rate r/F and achieves progress of i or more is at least λ -0.98 /2. Thus for λ offspring, we obtain Pr(∆(k, r) ≥ i) ≥ 1 -(1λ -0.98 /2) λ = 1 -O(exp(-λ 0.02 /2)) = 1o(1). If the failure event happens, we estimate ∆(k, r) pessimistically by -(n -2k)r/(F n) = O(i). Thus the statement holds.

For the third item, we take i := min{r, ln(λ)/ ln(en/k)}/F . Notice that for k < 7n/20 we have r u (k) < r u (7n/20) = (25/27) ln λ < 0.93 ln λ. Applying Lemma 2.143 with r/F ≤ r u (k) = o( √ n) we obtain (1r/(F n)) n ≥ (1o( 1))e -r/F . Therefore the probability that one offspring using rate r/F < 0.93 ln λ makes a progress of at least i is lower bounded by (assuming n large enough) 1))e -r F > k en i e -0.94 ln λ ≥ λ -1/F -0.94 > λ -0.98 .

k i r F n i 1 - r F n n ≥ k i • r F n i (1 -o(
Thus for λ offspring, we obtain Pr(∆(k, r) ≥ i) ≥ 1 -(1λ -0.98 /2) λ = 1o(1/ ln(λ)). If the failure event happens we estimate ∆(k, r) pessimistically by -(n -2k)r/(F n) = O(ln λ). The contribution of failure events is o(1) which is also o(i). Therefore the third statement holds.

As discussed, our aim is to show that r t /F or F r t stays in the right range frequently enough such that the overall average drift is still logarithmic. We notice that small rates r t < r l intuitively do not have a negative effect, therefore we focus on the probability that r t < F r u . Since r u monotonically decreases when k decreases, we need to analyze whether r still stays in the right range if there are large jumps in fitness distance k. Intuitively, the speed at which the mutation rate is decreased is much higher than than the decrease of fitness distance. To make this rigorous, we first look at the probability of large jumps, as detailed in the following lemma.

We first consider the case k t+1 ≥ k t (equivalent to r u (k t+1 ) ≥ r u (k t )). In this case X t+1 -X t ≤ 1 thus Pr(X t+1 ≥ 1 ∩ k t+1 ≥ k t | X t < 0) = 0 and Pr(X t+1 -1 ≥ 1 ∩ k t+1 ≥ k t | X t ≤ 1) = 0. It remains to consider Pr(X t+1 -X t ≥ a ∩ k t+1 ≥ k t | X t > 1) with -1/2 ≤ a ≤ 1, and Pr(X t+1 -1 ≥ a ∩ k t+1 ≥ k t | 0 ≤ X t ≤ 1) with 0 < a < 1.

If r t+1 = r t /F then X t+1 -X t ≤ -1. Clearly X t+1 -X t ≥ a ≥ -1/2 is impossible. It also makes X t+1 ≥ 1 with 0 ≤ X t ≤ 1 impossible. Thus, the two probabilities above are bounded by Pr(r t+1 = F r t ∩ k t+1 ≥ k t | X t ≥ τ ) ≤ Pr(r t+1 = F r t | X t ≥ τ ) = λ -Ω(1) according to Lemma 5.32.

It remains to consider k t+1 < k t (equivalent to r u (k t+1 ) < r u (k t )). We make a case distinction based on the value of (n -2k t ) 2 .

Case 1: (n -2k t ) 2 < 2F n ln λ. In this case, r u (k t ) = n 2 ln λ/(12(n -2k t ) 2 ) ≥ n/(24F ) which means that X t < 1 for all rates r ≤ n/(2F ). Thus Pr(X t+1 -X t < a ∩ k t+1 < k t | X t > 1) = 0. When computing Pr(X t+1 -1 ≥ a ∩ k t+1 < k t | X t ≤ 1), we notice that X t+1 ≥ 1 + a implies log F ((n/2F )/r u (k t+1 )) ≥ 1 + a + τ . Furthermore, Therefore a necessary condition for X t+1 ≥ 1 + a while X t ≤ 1 and (nk t ) 2 ≤ 2F n ln λ is k tk t+1 ≥ ((4F (1+a)/2 /10 1/4 -√ 2F )/2) √ n ln λ > (6F a/2 -4) √ n ln λ. We notice that E(k t+1k t ) > 0, applying Lemma 5.7 and using a union bound we obtain for ∆ := (6F a/2 -4) √ n ln λ > 2 √ n ln λ that Pr (k t -k t+1 > ∆ | X t ≤ 1) = Pr (k t+1 -k t < -∆ | X t ≤ 1)

n/2F r u (k t+1 ) = 12(n -k t+1 ) 2 (
< Pr (k t+1 -k t < E(k t+1 -k t ) -∆ | X t ≤ 1) < λ exp -∆ 2 2(n/2 + ∆/3) < λ exp -∆ 2 n + ∆ = λ -Ω(1+a) .

Therefore Pr(X t+1 -1 ≥ a ∩ k t+1 < k t | X t ≤ 1) = λ -Ω(1+a) .

Case 2: (n -2k t ) 2 ≥ 2F n ln λ. Let σ 2 t := r u (k t )/r u (k t+1 ) = (n -2k t+1 ) 2 /(n -2k t ) 2 , then X t+1 -X t ∈ {1 + log F (σ 2 t ), -1 + log F (σ 2 t )}. We rewrite for X t > 1 and a ≥ -1/2 Pr (X t+1 -X t ≥ a ∩ k t+1 < k t | X t )

≤ Pr r t+1 = r t /F ∩ σ 2 t ≥ F a+1 | X t + Pr r t+1 = F r t ∩ σ 2 t ≥ F a-1 | X t ≤ Pr σ 2 t ≥ F a+1 | X t + Pr σ 2 t ≥ F a-1 | X t 1 a>2 + Pr (r t+1 = F r t | X t ) 1 a≤2 ,
(5.5) as well as for X t ≤ 1 and a > 0

Pr (X t+1 -1 ≥ a ∩ k t+1 < k t | X t ) = Pr (X t+1 -X t ≥ 1 + a -X t ∩ k t+1 < k t | X t ) ≤ Pr r t+1 = r t /F ∩ σ 2 t ≥ F a+2-Xt | X t + Pr r t+1 = F r t ∩ σ 2 t ≥ F a-Xt | X t ≤ Pr σ 2 t ≥ F a+1 | X t + Pr r t+1 = F r t ∩ σ 2 t ≥ F a-Xt | X t , (5.6)
where the second item in the above inequality (5.6) is furthermore bounded in (5.7) by making a distinction between X t ≥ τ ∧ a ≤ 2 and the remaining cases.

Pr

r t+1 = F r t ∩ σ 2 t ≥ F a-Xt | X t ≤ Pr σ 2 t ≥ F a-Xt | X t 1 Xt<τ ∨a>2 + Pr (r t+1 = F r t | X t ) 1 Xt≥τ ∧a≤2 .
(5.7)

Applying Lemma 5.32 we see that both Pr (r t+1 = F r t | X t ) 1 a≤2 from (5.5) and Pr (r t+1 = F r t | X t ) 1 Xt≥τ ∧a≤2 from (5.7) are of order λ -Ω(1) . This Ω(1) exponent is sufficient to prove the lemma for a ≤ 2. We also notice that the event σ 2 t ≥ F a-τ subsumes all the other remaining events in inequalities (5.5), (5.6), and (5.7). Therefore it remains to validate Pr σ 2 t ≥ F a-τ | X t ≤ λ -Ω(a+1) for a ≥ 0. To ease representation, let s := F (a-τ )/2 -1 ≥ F -τ /2 -1 = (10/9) 1/4 -1 > 1/40. Since s = Ω(1 + a), proving Pr(σ t ≥ 1 + s | X t ) = O λ -Ω(s) is sufficient to conclude the analysis of this case and therefore the lemma. We rewrite

Pr (σ t ≥ 1 + s | X t ) = Pr n -2k t+1 n -2k t ≥ 1 + s | X t = Pr (k t -k t+1 ≥ s(n -2k t )/2 | X t ) .
Let ∆ := (s/2 + p)(n -2k t ) for 0 < p ≤ 1/2. Applying Lemma 5.7 and using a union bound we obtain Pr (σ t ≥ 1 + s | X t ) < λ exp max < λ expmin s n ln(λ)1 pn≤∆ + 42s ln(λ)1 pn>∆ = λ -Ω(s) .

We finally use Lemma 5.8 and Lemma 2.12 to obtain a logarithmic drift on average. After this major effort, it is a matter of a relatively straightforward drift analysis of fitness distance to obtain the following bound on the time to leave the far region.

Theorem 5.9. The (1,λ) EA with self-adapting mutation rate reaches a OneMaxvalue of k ≤ n/λ within an expected number of O(n/ log λ) iterations, regardless of the initial mutation rate. Furthermore, with probability at least 1o(1), it holds k t ≤ 2n/λ and r t ≤ (7/9) ln λ for some t = O(n/ log λ).

Proof. We first argue that within an expected number of O( √ n) generations we will have k t < n/2. Consider the case that k t ≥ n/2 and let the independent random variables X and Y denote the number of flips in k t one-bits and (nk t ) zero-bits, respectively, in an offspring using rate p = r/n. Referring to Lemma 2.16 for p ∈ [2/n, 1/2] we obtain, using similar arguments in the proof Lemma 5.32 that Pr(X ≥ E(X) + 1) = Θ(1) and Pr(Y ≤ E(Y )) = Θ(1). Then Pr(X -Y ≥ E(X) -E(Y ) + 1) = Θ(1). Since E(X) ≥ E(Y ), the probability that an offspring choose rates r ∈ {r t /F, F r t } with 2 ≤ r ≤ n/2 and have X -Y ≥ 1 is at least 1/2 • Θ(1) = Θ(1). Since the best of λ = Ω(ln n) offspring is selected, the probability that k t+1 ≤ k t -1 holds is at least 1 -exp(-Θ(λ)) = 1o(1/n 2 ). By an additive drift theorem, it takes O(max{k 0n/2, 0}) = O( √ n) iterations from the initial random search point to reach a parent with fitness distance less than n/2. Without loss of generality, we can now assume k 0 < n/2. Consider the number of one-bits flips X and zero-bits flips Y in a parent with fitness distance k t < n/2 and rate 2 ≤ r < n/2. As argued above Pr(X -Y ≥ E(X) -E(Y ) + 1) = Θ(1). Since

k t -(E(X) -E(Y )) = k t -(k t -(n -k t ))r/n = k t (1 -r/n) + (n -k t )(r/n) < n/2
for all r < n/2, the probability that an offspring has fitness distance at most n/2 -1 is Θ(1). Thus for λ = Ω(ln n) offspring, we have Pr(k t+1 < n/2) ≥ 1 -exp(-Θ(λ)) = 1o(1/n 2 ). Since that we aim at proving a hitting time of O(n/ ln λ) and only consider phases of this length, we may furthermore assume k t < n/2 for all t ≥ 0, which only introduces an o(1) error term by a union bound.

Define random variables X t := log F (r t /r u (k t ))τ with τ = log F (3/ √ 10) < 0.

We notice that when (n -2k t ) 2 ≤ 2F n ln λ we have X t < 1. If r t ≥ F r u (k t ), according to Lemma 5.32, with probability 1o(1) we have r t-1 = r t /F . Therefore within O(ln n) iterations we will obtain X t ≤ 1. The idea of the remaining proof is to compute an average drift for any fixed distance using the distribution of mutation rates, and then to apply the variable drift theorem to obtain a runtime bound. Applying Lemma 5.8 and Lemma 2.12 to the X t , we see that Pr(r t ≥ F 1+a+τ r u (k t )) ≤ λ -Ω(a) for all a > 0.

Let r (i) , i ∈ Z, denote the rate between (F i r u (k), F i+1 r u (k)] corresponding to fitness distance k. Thus, for all i ≥ 1, we obtain Pr r (i) ≤ Pr r t > F i r u (k t ) ≤ Pr r t ≥ F 1+(i-1-τ )+τ r u (k t ) ≤ λ -Ω(i-1-τ ) .

According to Lemma 5.6, E(∆(k, r (i) )) ≥ -(1 + o(1))(n -2k)r (i) /n) for i ≥ 1 and E(∆(k, r (0) )) ≥ Ω((n -2k)r (0) /n). The contribution of the negative drift is a lower order term compared to the contribution of the positive drift. Let ∆ (k) denote the average drift at distance k. We obtain ∆ (k) = i∈Z E(∆(k, r (i) )) Pr(r (i) ) ≥ (1o(1)) i≤0 E(∆(k, r (i) )) Pr(r (i) ).

We notice that i≤0 Pr(r (i) ) = 1o(1) and E(∆(k, r (i) )) > 0 for all i ≤ 0. According to Lemma 5.31, with at least constant probability r t = Ω(r l (k t )). Since for any rate r = Ω(r l (k)) and r ≤ F r u the drift is E(∆(k, r)) ≥ Θ(ln(λ)/ ln(n/k t )) according to Lemma 5.6, the average drift satisfies ∆ (k) ≥ Θ(ln(λ)/ ln(n/k)).

Using the variable drift theorem (Theorem 2.4) and the fact that To prove the second statement of the theorem, we notice that the corresponding upper bound on the rate for k t = o(n) is r u (k t ) ≤ (10/9)(U (k t )) ln λ = ((10/9)(2/22) + o(1)) ln λ < (1/9) ln λ and the occupation probability satisfies Pr(r t ≤ (7/9)F ln λ | k t = o(n)) ≥ 1λ -Ω(1) = 1o(1). Therefore with probability 1o(1), the first iteration such that k t ≤ 2n/λ has rate r t ≤ (7/9) ln λ. We then argue for this iteration that with high probability it satisfies r t+1 = r t /F and k t+1 ≤ 2n/λ. The probability of being no worse than parent using mutation probability p ≤ (7/9) ln(λ)/n is at least (1p) n ≥ (1o(1))λ -7/9 > λ -8/9 . Therefore, Pr(k t+1 ≤ k t | r t ≤ (7/9)F ln λ) ≥ 1 -1λ -8/9 /2 λ = 1o(1).

Furthermore Pr(r t+1 = F r t | k t = o(n), r t ≥ (7/9) ln λ) ≤ λ 1-(23/22)7 = o(1). Then we obtain an iteration with k t ≤ 2n/λ and r t ≤ (7/9) ln λ with probability 1o(1).

The Near Region

We now analyze the drift in rate and fitness distance in the regime in which the fitness distance satisfies k = k t = O(n/λ), the so-called near region. Informally speaking, this region is responsible for the (n log n)/λ term in the expected number of generations since here the probability of an improvement is only O(1/λ) and the offspring population can boost this probability by a factor of Θ(λ), assuming constant rate.

We start with a preparatory lemma determining the probability of making progress in one mutation and similar events. Lemma 5.10. Let 0 < k ≤ 3n/λ, and r = o(λ 1/4 ). Let x ∈ {0, 1} n with fitness distance f (x) = k. Let y ∈ {0, 1} be obtained from x by flipping each bit independently with probability r/n. Consider the probabilities p -(r) := Pr(f (y) < f (x)), p 0 (r) := Pr(f (y) = f (x)), p (r) := Pr(∀i ∈ [1..n] : x i = 0 =⇒ y i = 0), that is, the probabilities that the offspring is better than the parent, that is is equally good, and that none of the 0-bits of the parent were flipped in the generation of the offspring.

Then

(1o(1)) kr n e -r < p -(r) < (1 + o(1)) kr n e -r , (1o( 1))e -r < p 0 (r) < (1 + o( 1))e -r , (1o( 1))e -r < p (r) < (1 + o( 1))e -r .

Proof. We regard the number X of flips in the k one-bits ("good flips" which reduce the fitness distance) and the number Y of flips in the (nk) zero-bits of the parent ("bad flips" which increase the fitness distance). Then p -(r) is at least

+ k 2 r 2 2n 2 1 - r n n-2 + 2k-1 i=3 (i -1) r n i 1 - r n n-i k i/2 n -k i/2 < kr n 1 - r n n-2 1 - r n + kr 2n + 2k-1 i=3 r n i 1 - r n n-i (kn) i/2 < (1 + o(1)) kr n 1 - r n n + 2k-1 i=3 kr 2 n i/2 1 - r n n-i < (1 + o(1)) kr n e -r .
Similarly for p 0 (r) we have

p 0 (r) > Pr(X = Y = 0) = 1 - r n n ≥ (1 -o(1))e -r .
We show that the process (k t , r t ) reaches (0, F ) in time T * with probability at least 1 -1/e 2 . We use a two-dimensional drift argument. Let γ = 2F and define g : N × N → R by g(k, r) = k + γ(r -F ) for all k and r. We show that if for some t we have (k, r) = (k t , r t ), then (k , r ) := (k t+1 , r r+1 ) satisfies E(g(k , r )) ≤ g(k, r)(1 -λ 10n )

(5.9) when assuming n to be sufficiently large.

There is nothing to show in the artificial case when k > 3n/λ as we have, by definition, g(k , r ) = 0 in this case. Among the interesting cases, we consider first that r = F . We obtain an improvement in fitness in particular if there is an offspring that uses rate r/F = 1, flips exactly one of the k missing bits, and flips no other bit. Hence the probability to make a positive fitness progress is at least

1 -(1 -1 2 (1 -1 n ) n-1 k n ) λ ≥ 1 -(1 -k 2en ) λ ≥ 1 -exp(-kλ 2en ) ≥ kλ 3en ,
where we used (1 -1 n ) n-1 ≥ 1 e , kλ 2en ≤ 3 2e < 3 2 • 1 2 and Lemma 2.14 4. The expected negative progress is at most λF 2 exp(-(1 + o(1)) 1 2e λ) as shown in (5.8). This negative drift can be assumed to be O(n -2 ) by taking the implicit constant in the assumption λ = Ω(log n) large enough. Consequently, E(k ) ≤ k -1 3e λk n . Regarding r , we note that by Lemma 5.12 we have Pr(r = F 2 ) ≤ (1 + Let now be r > F . Note that the minimum fitness loss among the offspring is at most the minimum number of bits flipped, which in expectation is at most the number of bits flipped in the first offspring, which is exactly F r. Consequently, we have E(k ) ≤ k + F r. For r , we note that by Lemma 5.12, we have r = F r with probability at most exp(-9r) and we have r = r F otherwise. Consequently, E(r ) ≤ F r exp(-9r) + r F . This yields

E(g(k, r) -g(k , r )) ≥ -F r + γ(r -F r exp(-9r) -r F ) ≥ r(-F + γ -F exp(-9F 2 ) -1 F ) ≥ r(-F + γ -2 F ) ≥ 31r = r + 30r ≥ F 2 + 30r ≥ 32 2 + 30r ≥ λ 10n (k + γr) ≥ g(k, r) λ 10n ,
where we used that λ ≤ 2n; note that λ > 2n gives k 0 = 0. We have thus shown (5.9) for all (k, r). Since we start the process with a gpotential of at most g(2n/λ, F ) = 2n λ , the multiplicative drift theorem gives that after t = 10n λ (2 + ln( 2n λ )) iterations, we have Pr(g(k t , r t ) > 0) ≤ 1 e 2 . Consequently, with probability 1 -1 e 2 , the potential is zero at time t, which implies k t = 0 or k t > 3n λ . By Lemma 5.14, note that λ = Ω(log n) implies t = O(n) = o(nλ), the probability that k t > 3n λ is o(1), hence with probability at least 3 4 , we have indeed k t = 0.

Theorem 5.16. Assume k 0 ≤ 2n λ and r 0 ≤ 7 9 ln λ. Then there is a t = O(n ln(n/λ)/λ) such that with probability at least 1 2 , we have k t = 0.

1 n and the (1,λ) EA with fitness-dependent mutation rate p = max{ ln λ n ln(en/d) , 1 n } as presented in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF].

The results clearly show that the update factor of F = 32 used in our mathematical analysis gives sub-optimal results for these values of λ and n. Recalling the working principle of the self-adaptive (1,λ) EA, this is not overly surprising. Even using the minimal possible rate r = F , the algorithm creates half of the offspring using an incredible large mutation probability of F 2 /n = 1024/n. It is quite clear that this cannot be overly effective, but this can also be seen from the figure. The runtime of the self-adaptive (1,λ) EA with F = 32 is very close to the runtime of the static (1,λ) EA for half the λ-value, suggesting that half the offspring created by the self-adaptive (1,λ) EA, most likely the ones created with a mutation rate of F 2 /n, had no impact on the process.

The results in Figure 5.2 also show that the fitness-dependent mutation strength of [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] leads to a very good performance. In principle, of course, it is clear that the best fitness-dependent rate gives better results than any self-regulating rate since the latter needs to use also sub-optimal rates to find out what is the best rate. That the rate suggested in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF], a paper mostly concerned with asymptotic runtimes, shows such good results, is remarkable.

To ease the comparison of the algorithms having a similar performance, we plot in Figure 5.3 these runtimes relative to the one of the classic (1,λ) EA. This shows that in most cases, the EAs using a dynamic mutation rate outperform the classic (1,λ) EA. We also notice that the self-adaptive EA appears to outperform the one using the fitness-dependent rate for sufficiently large values of λ, e.g., for λ ≥ 200 when F = 1.2.

To understand how our tie-breaking rule influences the performance, we also ran the self-adapting (1,λ) EA without the bias towards smaller rates when breaking ties. In Figure 5.4, we again plot the average runtimes over 100 runs relative to the results of static (1,λ) EA. We use the three update factors 1.2, 2, and 32 and the two tie-breaking rule of preferring the smaller rate in case of ties (as in our theoretical analysis) and random tie-breaking, that is, choosing uniformly at random an offspring with maximal fitness and taking its rate as the new rate of the algorithm. While for the two larger factors F = 2 and F = 32, no significant differences are visible, we see that for F = 1.2 random tie-breaking surpasses biased tie-breaking significantly when λ become larger than 200.

To understand how the tie-breaking rule influences the mutation strength chosen by the algorithm, we plot in Figure 5.5 the mutation strength used at each fitness distance with a setting of n = 10000, λ = 500, and F = 1.2. We regarded one exemplary runs of our algorithm with each tie breaking rule. In each of these two experiments, we determined the set of all pairs (d t , r t ) such that in iteration t, the fitness distance of the parent individual was d t and its rate was r t . We then plotted these sets, where to increase the readability we connected the points to polygonal curve. This visualization clearly shows that random tie breaking lets the algorithm pick larger rates more frequently. Together with the better runtimes, it appears that biased tie-breaking has a small negative effect on the choice of the mutation strength.

Finally, we regard the question of how to set the initial rate r init . From the general experience that larger mutation rates are more profitable at the start of the search process, one could guess that it is a good idea to start with the largest possible rate r max = F log F (n/(2F )) instead of the smallest possible rate r min = F . For the settings used in Figure 5.5, that is, n = 10000, λ = 500, and F = 1.2, we obtain (as average of 100 runs) the runtimes given in Populations size λ Relative average runtime over 100 runs Self-adp (1,λ) EA using F = 32 Self-adp (1,λ) EA using F = 32 (breaking ties randomly) Self-adp (1,λ) EA using F = 2 Self-adp (1,λ) EA using F = 2 (breaking ties randomly) Self-adp (1,λ) EA using F = 1.2 Self-adp (1,λ) EA using F = 1.2 (breaking ties randomly)

  value Om(1 . . . 1) = n and minimal value Om(0 . . . 0) = 0. LeadingOnes The LeadingOnes problem counts the number of one-bits from left to right. It is another classic bit-counting problem. For bitstring x ∈ {0, 1} n of length n, its LeadingOnes value is defined as Lo(x) := max {i ∈ [0, . . . , n] | ∀j ≤ i : x j = 1} . It also has maximal value Lo(1 . . . 1) = n and minimal value Lo(0 . . . 0) = 0. Needle The Needle function returns the function value 1 for the all-ones bit string (1, . . . , 1) and function value 0 anywhere else (needle-in-a-haystack); i.e., Needle(x) := 1 x=1...1 .

  ln λ n ln(en/d(x)) , 1 n was shown to improve the classic runtime of

of

  Lemma 3.10. Let k ≤ n/2n 0.6 , x a search point with d(x) ≥ k and let r ∈ [0..n]. Since all random variables d(flip r (x)), d(flip n-r (x)), d(flip r ( x)), and d(flip n-r ( x)) are identically distributed, we can assume without loss of generality that Om(x) ≥ n/2 and that r ≤ n/2.

Theorem 3. 19 .

 19 For all ε > 0 the function Ropt,ε is monotonically increasing with respect to p. For all d ≤ n/2, Ropt,ε (d/n) and R opt (d, n) are odd values.

Figure 3 . 1 :

 31 Figure 3.1: The approximated drift A(k, p, 1p) for k = 1, 3, 5, 7. By Lemma 3.26 the function r → A(r, p, 1p) is maximized for r = 1 whenever p < 1/3.

3. 4 .

 4 Runtime Analysis for the Approximate Drift-Maximizer à * ε 51

  all the different OneMax-values taken by Y t until for the first time Y t ≤ n/ ln λ. By the additive drift theorem, it takes at most

Theorem 4. 8 .

 8 Let λ ≥ 26 and λ = n O(1) . Assume k ≤ n/ ln λ for the current OneMax-value of the self-adjusting (1+λ) EA. Then the expected number of generations until k ≤ n/λ is O(n/ log λ).

Theorem 4. 10 .

 10 Assume k ≤ n/λ for the current OneMax-value of the selfadjusting (1+λ) EA. Then the expected number of generations until the optimum is reached is O(n log(n)/λ + log n).

λλ

  Average runtime over 10000 runs Self-adj. (1+λ) EA Self-adj. (1+λ) EA (no random steps, F = 1.2) Static (1+λ) EA (p = ln(λ)/(2n)) Static (1+λ) EA (p = 1/n) (1+λ) EA using p = max(1/n, ln(λ)/(ln(en/d(x))Average runtime over 10000 runs Self-adj. (1+λ) EA Self-adj. (1+λ) EA (no random steps, F = 1.2) Static (1+λ) EA (p = ln(λ)/(2n)) Static (1+λ) EA (p = 1/n) (1+λ) EA using p = max(1/n, ln(λ)/(ln(en/d(x))))

Figure 4 . 1 :

 41 Figure 4.1: Static and Self-adjusting (1+λ) EA average runtime comparison (n = 5000) on OneMax and the corresponding interquartile ranges.

λ

  Average runtime over 10000 runs Self-adj. (1+λ) EA, 3 subpop. Self-adj. (1+λ) EA Self-adj. (1+λ) EA, 3 subpop. (no random steps) Self-adj. (1+λ) EA (no random steps)

Figure 4 . 2 :Figure 4 . 3 :Figure 4 . 4 :

 424344 Figure 4.2: Average runtime of the self-adjusting (1+λ) EA with two and three subpopulations each with and without random steps on OneMax (n = 5000) with corresponding interquartile ranges.

Theorem 5. 1 .

 1 Let λ ≥ C ln n for a sufficiently large constant C, and λ = n O(1) , and F = 32. Then the expected number of generations of the self-adapting (1,λ) EA to minimize OneMax is O(n/ log λ + (n log n)/λ), corresponding to an expected number of fitness evaluations of O(nλ/ log λ + n log n).

  to reduce the fitness distance to at most n/λ conditioning on the assumption that k t < n/2 for some t = O( √ n) and k t < n/2 for all t ≤ t = O(n/ log λ) is then Θ(n/ log λ). Thus the expected runtime of O(n/ log λ) holds with probability Ω(1) due to Markov's inequality. Using a restart argument we then obtain the claimed expected runtime since the expected number of repetition of a phase of length O(n/ log λ) is O(1).

≥

  p -(r) ≥ Pr(X = 1, Y = 0) (1o(1)) kr n e -r ,where the last estimate uses Lemma 2.14 3. Since r = o(λ 1/4 ), we have kr/n = o(1), kr 2 /n = o(1), and (kr 2 /n) 1.5 = o(kr/n). This allows to bound p -(r) from above byp -(r) < Pr(X ∈ {1, 2}, Y = 0) + 2k-1i=3Pr(X + Y = i, X > Y )

  o(1)) λk n F 2 exp(-F 2 ) and r = F otherwise. Hence E(r ) = F + (1 + o(1))(F -1)F 3 λk n exp(-F 2 ). Consequently, E(g(k, r)g(k , r )) ≥ 1 3e λk nγ(1 + o(1))(F -1)F 3 λk n exp(-F 2 ) = λk n ( 1 3eγ(F -1)F 3 exp(-F 2 )o(1)) ≥ λk n 1 10 = g(k, r) λ 10n .

Figure 5 . 4 :

 54 Figure 5.4: Relative average runtime of self-adapting (1,λ) EAs with different tie breaking rules on OneMax (n = 10 5 )

Figure 5 . 5 :

 55 Figure5.5: Mutation strengths used at a certain fitness distance level in two example runs of the self-adapting (1,λ) EA on OneMax (n = 10000, λ = 500, F = 1.2). For comparison, also the fitnessdependent rate proposed in[START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] is plotted. Recall that a mutation strength of r in the self-adapting runs means that in average half the offspring use the rate r/F and half use the rate rF .

  Algorithm 1 Blueprint of a unary unbiased black-box algorithm t ← 0. Choose x(t) uniformly at random from S = {0, 1} n .

for t ← 1, 2, . . . do Compute f (x(t -1)). Choose probability distribution p s on [0..t -1]. Randomly choose an index i according to p s . Choose a unary unbiased operator (p(•|x)) x∈{0,1} n . Generate x(t) according to p(•|x(i)).

  above. Consequently, E((x t )d(x t+H )) ≤ Hr max d(x t )/n and Pr(d(x t )d(x t+H ) ≥ 2Hr max d(x t )/n) ≤ exp(-Hr max d(x t )/3nr 2 max ). Without proof, we state the following elementary fact. Let r ∈ [1..r max ]. For d ∈ [0..n], let X d := X r d := max{d(x)d(flip(x, r)), 0}, where x is any search point with d(x) = d. In other words, X d describes the fitness gain in one iteration that starts with a search point with fitness f (x t ) and in which the mutation consists of flipping exactly r bits. Then E

	Lemma 3.33.

  In fact, we can discriminate N r/2 and N 2r by using Theorem 2.8 in the following way: we

	have
	Pr N r/2 ≤	λ 4	e -r 2	≤ exp -(1 -o(1)) 3 λ 16 ≤ exp -(1 -o(1)) 1 λ 7/8 e -r 2 16 < 0.175,
	for sufficiently large n, since r ≤ (ln λ)/4 and λ ≥ 45. Similarly, we obtain

  and use this to obtain a high value for Pr

  1. The negative drift of fitness for too high rates r ≥ F r u is bounded by When k ≥ 7n/20 the positive drift of fitness for good rate r ≤ F r u is bounded by

	E(∆(k, r)) ≥ -1 + o(1)	n -2k n	r F	.
	2. E(∆(k, r)) ≥ 1 -o(1) • 10 -4 n -2k n	•	r F	+ min ln λ,	r F	.
	3. When n/λ < k < 7n/20 the positive drift of fitness for good rate r ≤ F r u is bounded by
	E(∆(k, r)) ≥ 1 -o(1) min	r F	,	ln λ F ln(en/k)	.

  2F )n ln λ ≥ F 1+a+τ = 3F 1+a √ 10 if and only if (nk t+1 ) 2 ≥ 16F 1+a n ln λ √ 10 .

  We notice that ∆ ≥ (s/2) 2F n ln(λ) = 4s n ln(λ) and (s/2 + p) 2 /((1p)p) attains the minimal value s(2 + s) > 2s when p = s/(2(s + 1)). Using the fact that(n -2k t ) 2 /n ≥ 2F ln(λ) and s > 1/40, Pr (σ t ≥ 1 + s | X t ) < λ exp -min s

	<λ exp <λ exp -min max 0<p≤1/2 0<p≤1/2	0<p≤1/2 1 pn≤∆ + 2(1 -p)(pn)(1 + 1/3) -∆ 2 2(1 -p)(pn + ∆/3) -∆ 2 1 pn≤∆ + -∆ 2(1 + 1/3) ∆ 3 ∆ 2 3(1 -p)(pn) 1 pn>∆	1 pn>∆
		√	n ln λ1 pn≤∆ +	(2s)2F ln λ 3	1 pn>∆

  Table 5.1. So indeed an initialization with a larger rate gives some improvement. Since it might be a particularity of the

	1.6
	1.4
	1.2
	1
	0.8
	100	200	300	400	500	600	700	800	900 1,000

We report in the following the mean and relative standard deviations of our experiments by expressing, for example, the previous numbers as 45.5 • 10 6 ± 4.48%.

As usual in the analysis of algorithms, we write log when there is no need to specify the base of the logarithm, e.g., in asymptotic terms like Θ(log n). To avoid the possible risk of an ambiguity for small arguments, as usual, we set log x = max{1, log x}. All other logarithms are used in their classic meaning, that is, for all x > 0, we denote by ln x the natural logarithm of x and by log 2 x its binary logarithm.

In this part of the proof, we use the fact that F = 32. This does not mean that for other not too small values of F we would not obtain similar results, but it increases the readability to work with this concrete value.

Algorithm 7 Randomized local search with self-adjusting mutation strength. The parameters of the algorithm are the maximum mutation strength r max , the learning rate δ, and the forgetting rate ε. The operator flip(x, r) generates from x a new search point by flipping exactly r random bit positions.

Initialization:

Choose x ∈ {0, 1} n uniformly at random. for r ← 1, 2, . . . , r max do (v[r], w [r]) := (0, 0). Set r * ← 1.

Optimization: for t ← 1, 2, . . . do z ← random([0, 1]). if z ≤ δ then% learning iteration r ← random({1, . . . , r max }). y ← flip(x, r).

The main result of this section is a proof that our algorithm with reasonable parameter settings very precisely detects the optimal mutation strength. It thus, apart from the learning iterations, has the same performance as the randomized local search algorithm with fitness dependent mutation strength. The main technical challenge in this analysis are the dependencies between the progress of the algorithm and the learning system trying to estimate the velocities. We overcome these, among others, via a domination argument developed in [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF] (Lemma 1.20).

Throughout this section, we assume that r max is a constant independent of n. For simplicity, we only regard the parameters ε = n -0.99 and δ = n -0.01 , but remark that broader ranges of these parameters would work as well. In addition to the notation introduced in the previous section, we write r * t for the number of bits flipped in a non-learning iteration. We also define the fitness distance d(x) = nf (x) for all x ∈ {0, 1} n .

We start with two elementary results on the fitness progress made in one iteration. We frequently use two elementary facts about the progress from flipping a constant number of bits. Lemma 3.32. Consider a run of our algorithm. Let t and H be such that d(x t )H ≥ n 1.01 . Then d(x t+H ) ≥ d(x t )(1 -2Hr max /n) with probability 1 -exp(-Ω(n 0.01 )).

Proof. Consider an iteration t + i that creates x t+i from x t+i-1 . Independent of what happened in the previous iterations, the progress d(x t+i-1 )d(x t+i ) is dominated by the number of 0-bits (of x t+i-1 ) that are flipped in the mutation step, which again is dominated by the number of flipped positions that were 0 in x t . Consequently, d(x t+i-1 )d(x t+i ) is dominated by a hypergeometric distribution with parameters n, d(x t ), r max . By Lemma 1.20 of [START_REF] Doerr | Analyzing randomized search heuristics: tools from probability theory[END_REF], d(x t )d(x t+H ) is dominated by a sum of H independent random variables each having a hypergeometric distribution as where the last inequality used that ũ/( ũ + 2δ) ≥ 1/3 since δ ≤ ũ. Using n/k ≤ 20/7 and r ≤ n 2 ln λ/(12(n -2k) 2 ), we obtain

Plugging the last estimate into inequality (5.4), we obtain

which proves the statement in this lemma.

For k < 7n/20, we need a more careful analysis, where we will estimate the expected progress on fitness averaged over the random rates the algorithm may have at a time. Hence, we assume a fixed current fitness but a random current rate and compute the average drift of fitness with respect to the distribution on the rates. This approach is similar to the one by Jägersküpper [START_REF] Jägersküpper | Combining Markov-chain analysis and drift analysis -the (1+1) evolutionary algorithm on linear functions reloaded[END_REF], who computes the average drift of the Hamming distance to the optimum when the (1+1) EA is optimizing a linear function, where the average is taken with respect to a distribution on all search points with a certain Hamming distance.

Of course, we want to exploit that a rate yielding near-optimal fitness progress is used most of the time such that too high (or too low) rates do not have a significant impact. To this end, Lemma 2.12 about occupation probabilities will be crucial.

We now define two fitness dependent bounds r l (k) and r u (k). We show in Lemma 5.6 that for any rate, if r/F or F r is within the bounds, then the algorithm has logarithmic drift on fitness. Definition 5.5. Let n/ ln λ < k < n/2 and F = 32. We define

where L(k) and U (k) are defined as in Definition 5.2.

We notice that Lemma 5.3 can be applied to all r > r u or r < r l because for all 7n/20 ≤ k < n/2, we have r u /(U (k) ln λ) = 22n/(12(2nk)) ≥ 22/(12(2 -0.35)) = 10/9. For k < n/ ln λ, we set r l to the minimal possible value of r. Finally note that r u is non-decreasing in k due to the monotonicity of n 2 /(n -2k) 2 and U (k).

Lemma 5.6. Let n/λ < k < n/2 with F = 32. Let ∆(k, r) denote the fitness gain of the best offspring using rate in {r/F, F r}. Lemma 5.7. Assume r ≤ n/2 and let Z(k, r) denote the fitness-distance increase when applying standard bit mutation with probability p = r/n to an individual with k ones. Then

Proof. Without loss of generality, we assume that the individual has k leading ones and nk trailing zeros. Let random variables Z 1 , . . . , Z n be the contribution to fitness distance increase in each position after standard bit mutation. Then

The random variables Z 1 , . . . , Z n are independent and Z(k, r) = n i=1 Z i . Similarly as in the proof of Lemma 5.3 2, we have

To apply Bernstein's inequality (Theorem 2.8), we construct Zi such that Zi = Z i + p for all 1 ≤ i ≤ k and Zi = Z ip for all k < i ≤ n. Therefore E( Zi ) = 0 and Var( Zi ) = Var(Z i ).

By assuming r ≤ n/2, we have p ≤ 1/2 and thus p -1 ≤ Zi ≤ 1p for all 1 ≤ i ≤ n. Using the fact that n i=1 Zi = Z(k, r) -E(Z(k, r)), Theorem 2.8 yields with b := 1 -p and σ 2 := (1p)pn = (1p)r that Pr

Similarly the lower tail bound holds.

We now use Lemma 5.7 to show that once r t ≥ F r u (k t ), there will be a strong drift for r t /r u (k t ) to decrease down to 1. Lemma 5.8. Let k t < n/2 and F = 32. Let τ := log F (3/ √ 10) and X t := log F (r t /r u (k t ))τ with r u (k t ) defined in Definition 5.5, we have

) for all a > 0.

Proof. Using the fact that r t+1 ∈ {F r t , r t /F }, we see that

According to the monotonicity that r u (k) increases with respect to k, we notice that

√ 10, which is sufficient to apply Lemma 5.32 since r u (k) ≥ (10/9)U (k) ln λ as defined in Definition 5.5.

Using again the fact that kr 2 /n = o(1), we have

Finally, for p (r)

Lemma 5.11. Consider one iteration of the self-adaptive (1,λ) EA starting with an individual of fitness distance k and rate r = o(λ -1/4 ). Then the probability that there is an offspring which uses rate r/F and which inherits all 0-bits from the parent (and thus is at least as good as the parent), is at least 1 -exp(-1 2 λ(1o( 1))e -r/F ).

Proof. We compute

The following lemma is the counterpart of Lemma 5.3 2, where now the optimal rate is the smallest possible value F . Again, we regard the event that all best offspring are created with the higher rate, since-due to our tie-breaking rule-only this leads to an increase of the rate. Different from Lemma 5.3 2, now the probability of making a rate-increasing step is no o(1) in general. If k t = Θ(n/λ) and r t = O(1), we still have a small constant probability of increasing the rate. Lemma 5.12. Let 0 < k ≤ 3n/λ and F = 32. The probability that all best offspring have been created with rate F r is at most (1 + o(1)) λkF r n e -F r when r < ln λ and it is at most exp(-9r) for all r.

Proof. Let first r < ln λ. According to Lemma 5.10,

Therefore with probability at least 1

, no offspring of rate F r is better than its parent. Furthermore, by Lemma 5.11, with probability at most exp(-

) there is no offspring using rate r/F and being equally good as its parent. Hence, the probability that a best offspring has been created with rate r/F is more than

Note that for r < ln λ, the second bound follows from the first. If r ≥ ln λ, then the second bound follows from applying Lemma 5.3 to U (k) = 1/11 + o(1).

We shall use the lemma above twice, first to bound the probability to have a certain rate (which will be needed to estimate the negative fitness drift) and second to estimate that a suitable two-dimensional drift is of the right order. We start with the occupation probability argument for the rate values. Lemma 5.13. Consider a run of the self-adaptive (1,λ) EA started with some search point of fitness distance k 0 ≤ 2n/λ and rate r 0 = F . While the current search point of the algorithm has a fitness distance of at most 3n/λ, the probability that the current rate is F i is at most exp(-8F i-1 ) for all i ∈ N ≥2 .

Proof. If the current search point has fitness distance at most 3n/λ and the current rate is r, then by Lemma 5.12 the rate in the next iteration is F r with probability at most exp(-9r); note that this estimate is not affected by a possible cap of the rate at r max .

Consequently, the random process describing the rates is such that from rate

we go to rate F i+1 with probability at most p i = exp(-9F i ).

Otherwise, we go to rate F i-1 if i ≥ 2 and stay at rate F if i = 1. By Lemma 2.13, note that we obviously have

, in each iteration (such that the fitness distance has never gone above 3n/λ) and for each i ≥ 2 the probability q i that the current rate is F i is at most

We use these occupation probabilities to estimate the drift away from the optimum ("negative drift"). From this we derive the statement that with high probability, the fitness distance does not increase to above 3n/λ in nλ iterations.

Lemma 5.14. In the situation of Lemma 5.13, the probability that the process within the first nλ iterations reaches a search point (as parent individual) with fitness distance more than 3n/λ, is o(1).

Proof. Consider a run of the self-adjusting (1,λ) EA starting in the situation of Lemma 5.13. Denote by X t the fitness distance at time t. We start by bounding the negative drift E(max{0, X t -X t-1 }) of the X process while it is at most 3n/λ. If the current rate is r, then by Lemma 5.11 with probability at least 1 -exp(-1 2 λ(1o( 1))e -r/F ) there is an individual that used rate r/F and that did not flip any zero-bit into a one-bit. Let us call this event "A" and note that, naturally, under this event the drift cannot be negative as the individual without flipped zeroes has at an least as good fitness as the parent.

We now analyze the case that A does not hold. Consider an individual conditional on that it uses rate r/F and at least one zero-bit was flipped into a one-bit. The number of such bad bits follows a distribution (X | X ≥ 1) with X ∼ Bin(n -X t-1 , r/F n) and has expectation at most 1 + r/F by Lemma 2.16. For an individual using rate rF , the expected number of bad flips is (nk) rF n ≤ rF . Consequently, noting that 1 + r/F ≤ rF when r ≥ F and F ≥ √ 2, the expected number of bad flips in all individuals (conditional on not A) is at most λrF and this is an upper bound on the negative drift. In summary, in an iteration starting with rate r, the negative drift is at most 1))e -r/F ).

(5.8) With Lemma 5.13, we can estimate the probability to have a certain rate. Hence the expected negative drift is 1))e -1 ).

Note that

In other words, the Y process collects all the moves of the X process that go away from the optimum until the X process goes above 3n/λ. By our above computation, we have E(Y t ) ≤ tλ -3(1-o(1)) . Consequently, by Markov's inequality, we have

for all t ∈ N. In particular, for t = nλ, we have Pr(Y t ≥ n/λ) ≤ λ -1+o(1) . Note that

Lemma 5.15. In the situation of Lemma 5.13, with probability at least 3 4 there is a

Proof. Since we are proving an asymptotic statement, we can assume that n is as large as we find convenient. Consider a run of the self-adjusting (1,λ) EA from our starting position. Let T be the first time that the fitness distance is larger than 3n/λ, if such a time exists, and T = ∞ otherwise. Let k t denote the fitness distance at time t and r t the rate used in iteration t, if t ≤ T , and (k t , r t ) := (0, F ) otherwise.

Proof. We first show that with good probability we quickly reach the initial situation of Lemma 5.15. The probability of observing R * -1 := log F (r 0 ) -1 ≤ log F ( 7 9 ln λ) -1 rate-decreasing steps in a row by Lemma 5.12 is at least

by the Weierstrass product inequality (Lemma 2.14 5).

The probability of not flipping any zero-bits in at least one offspring, resulting in not increasing fitness distance, is for rate r ≤ 7 9 ln λ at least 1 -exp(-1 2 λ(1o( 1))e -r/F ) by Lemma 5.11. By a union bound over R * -1 iterations, the probability of decreasing the initial rate to F in O(log log λ) iterations without losing fitness is at least 1 -0.001 -(R * -1) exp(-1 2 λ(1o( 1))e -r/F ) ≥ 5/6 for sufficiently large n. We can now apply Lemma 5.15 and obtain that with probability at least 3 4 we have found the optimum within t = O(n ln(n/λ)/λ) iterations. This show the claim.

Putting Everything Together

We can now put everything together to prove our main result.

Proof. Starting with arbitrary initialization, Theorem 5.9 along with a Markov bound yield that with probability Ω(1) after t = O(n/ log λ) iterations a search point is reached such that k t ≤ 2n/λ and r t < 0.6(ln λ). Assuming this to happen, the assumptions of Theorem 5.16 are satisfied. Hence, after another O((n log n)/λ) iterations the optimum is found with probability at least 1/2. Altogether, with probability Ω(1) the optimum is found from an arbitrary initial OneMax-value and rate within T * = O(n/ log λ + (n log n)/λ) iterations. The claimed expected time now follows by a standard restart argument, more precisely by observing that after expected O(1) repetitions of a phase of length T * the optimum is found.

Experimental Results

To gain some insight that cannot be derived from our asymptotic analysis, we performed a few numerical experiments. To this end we implemented the (1,λ) EA in C++11 using the default random engine to generate pseudo-random numbers. The runtime is still measured via the number of generations until optimum is found.

We first see in Figure 5.1 how fitness distance and mutation strength evolve in one run for n = 100, λ = 12 and F = 1.2. We used this small value of n to increase the readability of the figure, we used larger values for n in the remainder. Given the small value of n, we used a small mutation update factor of 1.2 instead of the value F = 32 used in our theoretical analysis. This run uses Algorithm 9 with r init = F . We see that the algorithm prefers large mutation strengths at the beginning and small mutation strengths near the end of the optimization process. We also see that fitness distance can increase occasionally, in particular, when the rate is higher (in the plot, this happened in iteration 52 and iteration 88).

In Figure 5.2, we display the average runtime over 100 runs of different versions of the (1,λ) EA on OneMax for n = 10 5 and λ = 100, 200, . . . , 1000. For our selfadaptive (1,λ) EA (Algorithm 9), we used the update strengths F ∈ {1.2, 2, 32}. We did experiments also for F = 1.05, but the results were clearly inferior, so to not overload this figure we do not visualize them. We always set the initial mutation strength to r init = F . We further regard the classic (1,λ) EA using a static mutation rate of OneMax test function that huge rates are initially beneficial, we would not give out a general recommendation to start with the rate r max , but only state that we observed moderate performance differences from using different initial rates, making the initial rate not the most critical parameter of the algorithm, but still one that can be worth optimizing. Populations size λ Average runtime over 100 runs (•10 4 ) Static (1,λ) EA using p = 1/n (1,λ) EA using p = max{1/n, ln(λ)/(ln(en/d(x)))/n} Self-adaptive (1,λ) EA using F = 32 Self-adaptive (1,λ) EA using F = 2 Self-adaptive (1,λ) EA using F = 1.2 Populations size λ Relative average runtime over 100 runs Static (1,λ) EA using p = 1/n (1,λ) EA using p = max{1/n, ln(λ)/(ln(en/d(x)))/n} Self-adaptive (1,λ) EA using F = 2 Self-adaptive (1,λ) EA using F = 1.2

Conclusions

We numerically computed the precise unary unbiased black-box complexity on OneMax problem. We showed that drift-maximization is near-optimal for this problem, thus the precise complexity can be achieved (apart from an additive o(n) term) by a simple hill climber with fitness dependent mutation rate.

After analyzing the suitable mutation strength, we proposed a self-adjusting choice of the mutation strength k for the hill climber. This use of k-bit flips instead of the usually preferred standard bit mutation with its random mutation strength allowed to much better exploit the most effective mutation strength. This self-adjusting choice allowed to find the optimal mutation strength automatically and on-the-fly. By this, also the risk of getting stuck in local optima, the known draw-back of k-bit flips, was overcome.

Based on the learning-inspired parameter control on randomized local search, we proposed and analyzed a new simple self-adjusting mutation scheme for the (1+λ) EA. It consists of creating half the offspring with a slightly larger and the rest with a slightly smaller mutation rate. Based on the success of the subpopulations, the mutation rate is adjusted. This simple scheme overcomes difficulties of previous selfadjusting choices, e.g., the careful choice of the exploration-exploitation balance and the forgetting rate in the learning scheme.

We proved rigorously that this self-adjusting (1+λ) EA optimizes the OneMax test function in an expected number of O(nλ/ log λ + n log n) fitness evaluations. This matches the runtime shown in [START_REF] Badkobeh | Unbiased black-box complexity of parallel search[END_REF] for a careful fitness-dependent choice of the mutation rate, which was also shown to be asymptotically optimal among all λ-parallel black-box optimization algorithms. Hence our runtime result indicates that the self-adjusting mechanism developed in this work is able to find very good mutation rates. To the best of our knowledge, this is the first time that a self-adjusting choice of the mutation rate speeds up a mutation-based algorithm on the OneMax test function by more than a constant factor.

After that, we analyzed the self-adaptive (1,λ) EA using a very simple scheme for mutating the mutation rate and proved that is achieves the expected runtime O(nλ/ log λ + n log n) on OneMax, which is optimal for all λ-parallel mutationbased unbiased black-box algorithms. Hence, we have identified a simple and natural example where self-adaptation of strategy parameters in discrete EAs can lead to provably optimal runtimes that beat all known static parameter settings. Moreover, a relatively complicated and partly unintuitive self-adjusting scheme for the mutation rate proposed can be replaced by our simple endogenous scheme.

The analysis of the (1,λ) EA has revealed a highly non-trivial stochastic process where drift happens in two dimensions, namely regarding fitness distance and mutation rate. We have advanced the techniques for the analysis of such two-dimensional drift processes, including a useful lemma about occupation probabilities. Altogether, Chapter 6. Conclusions we are optimistic that our research helps pave the ground for further analyses of self-adaptive EAs. Abstract : Many real-world optimization problems are too complex to be solved in polynomial time. One way to deal with such problems is using randomized search heuristics (RSHs), which produce solutions more efficiently by compromising on optimality, completeness, accuracy, or precision. RSHs first initialize a search point with a random position and then solve problems iteratively until a termination criterion is met. In each iteration, they repeat the following steps: generate one or more candidates; evaluate the quality of the new individuals; update the known information. Since RSHs do not require any other information than the objective values of the evaluated search points, we call them black-box optimization algorithms. RSHs are parametrized algorithms, and their performance typically depends very crucially on the value of these parameters. In this work, we contribute to our knowledge of how to control the parameters online in various ways. We study the ONEMAX function which is defined via {0, 1} n → R, x → n i=1 x i . In a first step, we prove that unary unbiased black-box algo-rithm needs n ln(n) -cn ± o(n) iterations, on average, to find an optimal solution for this problem, where c is a constant between 0.2539 and 0.2665. This runtime can be achieved with a simple (1+1)-type algorithm using a fitness-dependent parameter setting. We also show that this setting can be replaced by a self-adjusting one without losing efficiency. We then extend our self-adjusting strategy to population-based evolutionary algorithms (EAs) which use mechanisms inspired by biological evolution, such as reproduction, mutation, recombination, and selection. Roughly speaking, the main idea of the EAs is to create per iteration λ search points using two different parameter values. The parameter is then updated based on the one used in that subpopulation which contains the best search point. We propose a self-adjusting version of (1 + λ) and a self-adaptive version of the (1, λ) and prove that they both find the optimum in an expected number of best possible O(nλ/ log λ + n log n) iterations.

Universit é Paris-Saclay

Espace Technologique / Immeuble Discovery Route de l'Orme aux Merisiers RD 128 / 91190 Saint-Aubin, France