1 Introduction
Evolutionary computing techniques have been applied in a large variety of different settings ranging from classical optimization problems in the context of supply chain management and renewable energy [BM16, TWD13, NAW20] over to the creation of music and art [Dos13, Lew08, NAN20]. The easy applicability of evolutionary algorithms makes them attractive also to users from outside computer science disciplines and is one of the major reason for their success in a wide range of engineering applications such as the design of water networks [BDM15] or processing and planning in mining [MD10, OWBM13].
The theoretical understanding and analysis of evolutionary algorithms is key to further increase the applicability and performance of evolutionary computing methods in a wide range of settings. The area of runtime analysis as played a predominant role during the last 25 years in the area of theory of evolutionary computation when considering discrete optimization problems. The goal of this survey is to point out important research directions and their main results of the last 510 years. Due to the size of this research area, this survey cannot give a complete description of the progress in this field. We therefore focus on seven areas that from our (subjective) point of view are currently the most active and promising ones.
The area of drift analysis has provided a wide range of analytical methods that are frequently used for the runtime analysis of evolutionary algorithms. It establishes conditions for the progress of an evolutionary algorithm that lead to specific runtime bounds. We will summarize the most important drift theorems and their applications together with the challenges involved when using drift analysis in Section 2.
After that we turn to the parameterized complexity analysis of evolutionary computing in Section 3. This area investigates the runtime with respect to the given input size and important structural parameters of a given problem instance. It allows to give a more fine grained view on the runtime behavior and reveals how structural parameters influence the runtime. The analysis carried out in this area are focused on classical combinatorial optimization problems such as minimum vertex cover and the Euclidean Traveling Salesperson problems and we will summarize the main results for them.
Setting the parameters of evolutionary algorithms
is a key challenge in the profitable use of these heuristics. In Section
3, we discuss how recent theoretical works suggest to set the parameters. We also discuss different ways to let the algorithm optimize its parameters itself, which currently appears as a very powerful, easytouse approach.Dynamic and stochastic problems play a key role in many realworld applications and evolutionary algorithms have been shown to be very successful in dynamic and stochastic environments. The theoretical investigations in terms of runtime analysis for such problems have been started by Droste in the mid 2000s and a wide range of results have been obtained during the last 10 years. We will summarize such results in Section 5.
Many important problems can be formulated in terms of a submodular functions with a given set of constraints. The analysis and the design of evolutionary algorithms for submodular optimization problems has gained a lot of attention during the last 5 years. Various types of constraints as well as dynamic and stochastic settings have been investigated and provably efficient evolutionary algorithms outperforming previous stateoftheart greedy approaches have been designed. The most important results and the different areas investigated are presented in Section 6.
Estimationofdistribution algorithms
(EDAs) are evolutionary algorithms which do not evolve a population of good solution candidates, but a probability distribution on the search space that allows to sample good solutions. Due to the complicated nature of the underlying mathematical objects (a random process taking probability distributions as states), for a long time the theoretical understanding of these algorithms was very limited. The last few years, however, have seen great progress in this topic, both showing new advantages of EDAs such as robustness to noise and giving advice in how to set their parameters. We review some of these results in Section
7.2 Drift Analysis
Drift analysis has become one of the most heavily employed tools in the mathematical analysis of evolutionary algorithms (EAs). Interestingly, it is one of the few tool sets which were not imported from the classic algorithms field. Rather, the classic algorithms field is now starting to use the drift theorems developed in our field, see, e.g., [BLM20, GKK18, KU18, OE12].
Drift analysis as tool in the performance analysis of EAs builds on the insight that it is often easy to estimate the expected progress (with regard to some suitable measure) of an EA in one iteration. Drift analysis therefore tries to translate this information into estimates for the first time that a particular goal is achieved.
As a simple humorous example, inspired by a similar one from [Doe11], consider the following question. You have an initial capital of $1,000. Each day you go to your favorite pub and a drink random number of beers for an expected total price of $10. After how many days you are bankrupt?
If there was no randomness involved, that is, if you would spend exactly $10 each day, then obviously it takes exactly 100 days to spend your money. So does the answer change with randomness? Interestingly, it does not (of course, we can now only talk about the expected number of days to bankruptcy): The expected number of days until you have spend all your money is exactly 100, regardless of the distribution of the amount you spent per day (which could be different for each day, could depend on previous days, and could also take negative values). This is a simple application of the additive drift theorem (Theorem 1 below).
The additive drift theorem is intuitive, but is in fact a deep mathematical result. Also, we have to note that it is not true that “randomness never changes things”. Take for example the opposite process: You start with no money, but each day you earn an expected number of ten dollars. What is the expected time it takes until you have at least $1,000? Now we can only say that it is at least 100 days (with a slightly less direct application of the additive drift theorem), but it could be much larger. For example, if each day we earn $10,000 with probability and $0 otherwise, then if takes an expected number of 1000 days until we have at least $1,000.
Drift analysis was introduced to the field of evolutionary computation in the seminal work [HY01] of He and Yao. The additive drift theorem developed there from Hajek’s work [Haj82] was already the elegant tool we still use a lot, but many of its courageous applications, e.g., to the linear functions problem, were highly technical. For that reason, many researchers shied away from using this method and preferred classic arguments like Wegener’s fitness level technique [Weg01]. Over time, however, more elegant applications of the additive drift theorem, e.g., Jägersküpper’s [Jäg08] analysis of the linear functions problem, and drift theorems capturing better particular scenarios, e.g., the multiplicative drift theorem [DJW12a], paved the way to drift analysis becoming the possibly most powerful tool in the mathematical analysis of EAs.
2.1 Three True Drift Theorems
To show the beauty, simplicity, and power of drift analysis, we now present three central drift theorem. We call them true drift theorems to reflect that all three translate information on the expected onestep progress into a hitting time without further assumptions on the distribution of the onestep progress. We state these theorems in their most basic version and trust that the reader is able to derive more general looking, but equivalent versions via scaling, shifting, or mirroring the random process.
2.1.1 Additive Drift.
From a deeper mathematical result of Hajek [Haj82], He and Yao [HY01] derived the additive drift theorem and used it to prove several runtime bounds.
Theorem 1 (additive drift theorem).
Let
be a sequence of random variables taking values in some finite set
with . Let .
Assume that there is a such that for all and , we have . Then .

Assume that there is a such that for all and , we have . Then .
Without going into details, we note that the assumptions can be weakened slightly, e.g., one can replace the “pointwise drift requirement”, that is, the conditioning on , by an “average drift condition”, that is, conditioning only on [HY01]. Also, the first part is also true for arbitrary infinite sets and the second part is true also for bounded infinite sets ; see [LS18], where also a short and elegant proof of this result is presented.
The additive drift theorem gives good results if there is a roughly uniform progress regardless of time and state. In fact, as the two estimates together show, the additive drift theorem gives an exact estimate for the hitting time when the expected progress is known to be exactly at all times before hitting the target.
2.1.2 Multiplicative Drift.
For many natural optimization processes, the progress towards the optimum slows down when getting closer to the optimum. To use the additive drift theorem in such situations, the natural distance measure has to be transformed in such a way that the resulting expected progress is roughly uniform. Since the expected transformed progress is usually not just the transformation of the expected progress, such proofs can become technical and unintuitive.
Noting that a common situation is that the expected progress is roughly proportional to the distance to the target, in [DJW12a] a multiplicative drift theorem was derived from the additive drift theorem. With a simpler direct proof, the following variant was later shown in [DG13]. According to [Len20], the multiplicative drift theorem is the most often used drift theorem in the theory of evolutionary algorithms.
Theorem 2 (multiplicative drift theorem).
Let be a sequence of random variables over a state space with . Let . Assume that there is a such that for all and , we have . Then the following estimates hold.

.

For all , we have .
2.1.3 Variable Drift.
While indeed very many processes occurring in the analysis of evolutionary algorithms display an additive or multiplicative drift behavior, there remain processes in which the drift is decreasing when approaching the target (so that the additive drift theorem is hard to use), but not in a multiplicative fashion (so that the multiplicative drift theorem is hard to use). For these, socalled variable drift theorems can be applied. The first variable drift theorem for the analysis of evolutionary algorithms was proposed by Mitavskiy, Rowe, and Cannings [MRC09], however, the independently developed result of Johannsen [Joh10] appears to be used more often. The following is a variant of Johannsen’s result avoiding the use of integrals.
Theorem 3 (variable drift theorem).
Let be a sequence of random variables over a finite space . Assume that with . Let . Assume that there is a monotonically nondecreasing function such that for all and , we have . Then .
The above are, most likely, the three most important drift theorems. We mention that the only other real drift theorem (that is, not requiring additional assumptions on the onestep distribution) we are aware of is the following result proven in [DLO19]: Let a random process as in the multiplicative drift theorem be given, but with the drift condition replaced by the slightly stronger condition for some . Then . We do not know if this result will find other applications, so we state the result here maily to demonstrate that an only slightly stronger assumption on the drift – instead of – can lead to a drastically smaller hitting time – instead of .
2.2 Drift Results With Additional Requirements
The results presented in the previous section derive estimates for hitting times solely from the expected onestep progress; however, with two important restrictions: (i) except for the additive drift theorem, only upper bounds for hitting times can be obtained, and (ii) only processes can be analyzed in which there is a drift towards the target that can be uniformly bounded or that decreases when approaching the target.
Consequently, these drift theorems miss out a large number of behaviors of random processes that occur in the analysis of evolutionary algorithms. In this section, we briefly describe such behaviors and what solutions for their analysis exist. Unfortunately, and this is the reason why we shall state no precise result, all these tools not only require information on the expected onestep change, but also on the distribution of the onestep change (typically, that the onestep change is concentrated around its expectation). For all results, this is not a weakness of the result, but an intrinsic necessity.
2.2.1 Lower Bounds for Hitting Times.
From classic algorithms theory we know that it is very valuable to also have lower bounds on runtimes as these quantify how good our performance guarantees (upper bounds) are. If we have derived an upper bound from a certain drift behavior, say additive, multiplicative, or a certain variable drift, then the most natural approach would be to show a matching or nearmatching upper bound on the expected onestep progress and derive (via a suitable drift theorem) from it a lower bound on the runtime. This works perfectly for the additive drift theorem as it contains such matching upper and lower bound results.
For multiplicative and variable drift, the theorems presented in the previous section are missing such matching results, and this for good reason, namely because in general they are not true. As a simple example, consider the process on the state space , starting with probability one in , which leaves state to with probability and stays in otherwise. Apparently, we have , that is, we have perfect multiplicative drift with . The multiplicative drift theorem thus gives an estimate for the expected hitting time of . This is bestpossible in the sense that there are processes with multiplicative drift with which indeed need time, but for this particular process, the truth obviously is . This shows that a matching lower bound cannot exist without additional assumptions.
The assumption that usually gives the desired behavior (and the desired lower bounds) is that the onestep progress is concentrated around its expectation, typically with some exponential tails or by forbidding large progresses at all. We spare the details and point the reader to [Wit13, DDK18] for a multiplicative drift theorem for lower bounds and to [DFW11, GW18, DDY20] for variable drift theorems for lower bounds.
2.2.2 Increasing Drift.
All three main drift theorems require that the onestep progress is not increasing when approaching the target. This is a behavior often observed in evolutionary computation: The better the current solutions are, the harder it is to make progress. However, also the opposite behavior can be found, for example, when we consider how a better individual takes over a population. Here we would expect that the number of copies of the good individual increases in a multiplicative fashion (of course, only up to the point that a certain saturation is reached). Processes showing an increasing multiplicative drift have been analyzed in several papers dealing with populationbased EAs, most notably in Lehre’s [Leh11] levelbased theorem and many followup works. An explicit formulation of a drift result for such processes was given in [DK19]
. Again, an expected multiplicative onestep progress is not enough, but some additional concentration assumptions are necessary. Motivated by the application to population processes, the additional assumption was made that the onestep progress stochastically dominates a binomial distribution.
2.2.3 Negative Drift.
A different situation is that a process shows a drift away from the target and that we want to argue that it takes a long time to reach this target. Such a situation naturally arises again in lowerbound proofs. The first such drift theorem was given by Oliveto and Witt [OW11, OW12]. Like many results proven later, see again the survey [Len20], it shows that if there is a constant negative expected progress in some interval of length and the onestep changes have bothsided exponential tails, then with probability , the process takes time exponential in to reach the target.
A different approach to analyze a negative drift situation was taken in [ADY19]. Instead of the true process , one regards an exponential transformation for suitable constants , shows that has at most a constant additive drift, and then uses the lower bound part of the additive drift theorem to derive the desired result. Depending on how easy it is to compute the drift of the transformed process, this approach might be technically simpler than using the existing negativedrift theorems. Different from all existing negativedrift theorems, it allows to derive explicit constants in the exponent. As shown in [Doe20a], this approach can also give superexponential lower bounds.
2.3 Challenge: Finding the Right Potential Function
The results discussed so far show that we now have a decent number of drift theorems, which cover many different random processes. While surely new drift theorems will come up and existing ones will be polished, we are optimistic that the drift theorems developed in the last twenty years allow us to analyze most random processes occurring in the analysis of EAs.
What is less understood, and often still a challenge, is defining the right random process. To be able to apply a drift theorem, we need to define a random process that describes some aspect of the run of our EA on some problem. Formally speaking, we need a function that maps the full state of the algorithm after iteration into a real number , and this in a way that the process still contains some relevant information of the run of the EA (e.g., that a suitable hitting time of corresponds to the time when an optimum was first found) and in a way that a drift theorem can be applied. While there are some generic solutions to this technical problem, many questions are still open here and this might be the biggest challenge in the future of drift analysis.
A natural way to define the potential function is to take the fitness distance of the currentbest solution to the optimum. This works well when there is a good correlation between the remaining optimization time and the fitness distance as observed, e.g., for the simple benchmarks OneMax and LeadingOnes (note that the classic analyses [DJW02] stem from the time before drift analysis was introduced and hence use Wegener’s [Weg01] fitness level method) or combinatorial problems such as the minimum spanning tree problem (again, the classic proof [NW07] does not use drift, but the expected multiplicative weight decrease method) or the maximum satisfiability problem with clauses of length [DNS17].
An equally natural potential is the structural distance to the optimum, e.g., the Hamming distance in the case of pseudoBoolean optimization. This was used, e.g., to show that the EA with mutation rate , a constant strictly between and , optimizes any strictly monotonic function in time [DJS13].
Unfortunately, these two potentials do not suffice. The most famous example for which neither the fitness distance nor the structural distance work well is the linear functions problem, that is, the question how fast the simple EA optimizes a general linear pseudoBoolean function . With a sequence of more powerful potential functions, all different from fitness and structural distance, increasingly strong results were obtained [DJW02, DJW12a, DG13, Wit13].^{1}^{1}1We note that Jägersküpper with a clever averaging argument could also use the structural distance as potential function. Unfortunately, it remains unclear how to easily derive such potential functions. In fact, the only result regarding this question is a negative one, namely that to prove the results for larger mutation rates such as [DG13, Wit13], it is not possible to use one “universal” potential function for all linear functions, but the potential has to be chosen depending on the problem instance [DJW12b].
In three particular directions, we currently see the greatest lack of understanding how to define potential functions to use drift analysis. These are the following.
2.3.1 Drift Analysis for Representations Other Than Bit Strings.
Once a relatively compact analysis of the runtime of the EA with standard mutation rate on linear functions was found [DJW12a], the question was raised how far these methods could be extended. One direction are linear functions defined not on bit strings, but on higherarity representations . While the runtime estimate could be shown for the search space [DJS11], it was also shown in this work that there is no universal potential function from on. With instancespecific potential functions, an upper bound was shown in [DP12]. This extends the bound to all , but not beyond. It is an open problem whether larger indeed lead to an inferior runtime behavior or not. This example and the general shortage of works analyzing EAs with representations different from bit strings via drift analysis (we are only aware of [KLW15a, LW16, DDK18]) suggest that more work is needed in this direction.
2.3.2 Drift Analysis for Populationbased EAs.
All works described above, and in general the vast majority of runtime analyses building on drift arguments, only regard very simple EAs such as the EA or, occasionally, the EA or the GA. For such EAs, a potential function only needs to estimate the quality of the single parent individual. For EAs working with a nontrivial parent population, it is much harder to define a suitable potential function. In fact, the main work on lower bounds for such algorithms by Lehre [Leh10] used drift arguments only in the ancestral lines of single individuals and captured the effect of the whole population via family trees (see [Doe20b] for an alternative approach). Again for lower bound proofs, Neumann, Oliveto, and Witt [NOW09] and later [OW15, ADY19] used as potential (to be maximized) of a population in an algorithm maximizing the OneMax benchmark, where is a suitable constant. The main line of works on upper bounds [Leh11, DL15, CDEL18] defines an extremely complicated potential function on the populations that is, most likely, not easy to transfer to other problems. While these results show that drift analysis can be employed in the analysis of populationbased algorithms, more work seems necessary, in particular, on upper bounds analyses, for drift analysis to replace the classic fitness level arguments more often employed here, see, e.g., [Wit06, CHS09, ADFH18].
2.3.3 Drift Analysis for Dynamic Parameters.
With the popularity of dynamic parameter choices both in theory (see also Section 4.2) and practice, there is a strong need for mathematical methods to analyze such algorithms. From the perspective of drift analysis, again the challenge is to define a suitable potential function on the cross product of populations (which in the simplest case are just single individuals) and parameter values (or more generally, the full inner state of the algorithm). So far, we are only aware of the four works [DDK18, AAG18, Row18, DWY18a] providing solutions to this problem. In the interest of brevity, we refer to [DWY18b, Section 1.3] for a more detailed discussion, and state here only that our impression is that more work on this problem is necessary (and desirable) to ease future analyses of dynamic parameter settings.
3 Parameterized Complexity Analysis of Randomized Search Heuristics
Traditional runtime analysis investigates the runtime of an evolutionary computing technique with respect to the size of the given input. This takes a worst case perspective over all possible inputs without being able to distinguish important input characteristics that make a problem hard or easy to solve.
Parameterized analysis of algorithms [DF99] allows to investigate algorithms not just with respect to the worstcase behaviour regarding the length of the given input, usually denoted by , but also with respect to some additional parameter(s) that characterize the problem. A problem is called a fixed parameter tractable (FPT) with respect to a parameter iff there is an algorithm that runs in time , where is a function only depending on . We call an algorithm an FPT algorithm with respect to a parameter iff it runs in time . This implies that an FPT algorithm runs in polynomial time if is constant.
The approach of analyzing evolutionary algorithms in the context of parameterized complexity has been introduced by Kratsch and Neumann [KN13] although there are earlier analyses that investigate RLS and the (1+1) EA for the maximum clique problem on planar graphs [Sto06] and populationbased EAs with respect to the runtime dependent on the size of the cliques obtained [Sto07]. We call an evolutionary algorithm a fixedparameter evolutionary algorithm with respect to a parameter iff its expected optimization time is . As common in the runtime analysis of evolutionary algorithms, the expected optimisation time refers to the expected number of fitness evaluations until an optimal solution has been produced for the first time.
3.1 Results for Minimum Vertex Cover
algocf[t]
The minimum vertex cover problem is the classical problem in the area of parameterized complexity and several FPT algorithms are available. The input of the minimum vertex graph problem is an undirected graph and the goal is to find a minimum set of vertices such that each edge is covered by at least one node of , i.e. holds for all .
Kratsch and Neumann [KN13] showed that a simple evolutionary multiobjective algorithm called GSEMO (see Algorithm LABEL:alg:paramcomplex:gsemo) frequently used in the area of runtime analysis [NW06, GL10, FHH10] is able to compute a kernelization for the problem. A kernelization is a reduced problem where the decision for some nodes whether or not to include them has already been made in an optimal way. It is shown in [KN13] that such a kernelization can be obtained by using two different types of helper objectives as a second objective. The first one considered in the article is the number of uncovered edges of a given solution
. The second approach uses the optimal value of the linear programming relaxation of the graph consisting only of the uncovered edges of a given solution
. Note that both helper objectives estimate the degree of infeasibility of a solution which is quite common when using multiobjective models for singleobjective optimization problems in the context of evolutionary computing.Having obtained such a solution an alternative mutation operator flipping bits corresponding to nodes that are adjacent to so far uncovered edges can obtain an optimal solution in time which leads to the result that the examined evolutionary algorithms are fixed parameter evolutionary algorithms. It has also been shown that a factor approximation, , can be obtained in expected time , where is the value of an optimal solution, when using the LP relaxation as the second objective. This gives a tradeoff between approximation quality and runtime. Setting , it shows that the approach computes a factor approximation in expected polynomial time.
In the weighted vertex cover problem, each node has a positive weighted and the goal is to minimize the sum of the weights of the chosen nodes under the condition that all edges are covered. The use of the dual formulation of the vertex cover in form of edge sets has been investigated by Pourhassan et al. [PSN19]. They have generalized the edge based presentation by Jansen et al. [JOZ13] to the weighted case and shown that their evolutionary multiobjective algorithm is a fixed parameter algorithm for the weighted vertex cover problem. The authors have shown that a approximation for the weighted vertex cover problem is obtained by the algorithm in expected polynomial time and presented a populationbased approach which achieves a approximation in expected time . Setting , it shows that the approach computes a factor approximation in expected polynomial time for the weighted vertex cover problem.
3.2 Results for the Euclidean Traveling Salesperson Problem
The traveling salesperson problem is another very prominent problem in the area of combinatorial optimization. Given a set of cities , and distances between them the goal is to compute a tour of minimal cost visiting each city exactly one and returning to the origin. A possible solution for the TSP is usually given by a permutation of the given cities and the goal is to find a tour that minimizes
In the context of parameterized analysis of evolutionary algorithms, the Euclidean TSP has been investigated by Sutton et al. [SNN14]. Here each city is given as coordinates and the distance between city and is given as . The Euclidean TSP is still NPhard but admits a PTAS. In terms of parameterized analysis, the impact of the number of inner points has been considered which is given by the number of points that do not lie on the convex hull of the points in 2D. We denote by the points on the convex hull and the number of inner points.
The Euclidean TSP can be solved by classical algorithms in time using dynamic programming [DHOW06]. This makes use of the properties that an optimal solution has to visit the points of the convex hull in the order as they appear on the hull. The difficult task is then to ”fill in” the inner points such that an optimal solution is obtained.
Investigations in the area of evolutionary algorithms focused on the runtime analysis with respect to the number of inner points for the Euclidean TSP. The first part of the analysis carried out in [SN12] analyzes the expected time until the classical (1+1) EA using inversions as the mutation operators has computed a tour that is intersection free. The analysis depends on the progress that can be made by inversion operations removing an intersection and this progress depends on the angle between any three points in the given set of cities. It is assumed that any three points are not collinear, i.e. do not lie on a single straight line. For an intersection free tour it is known that the points on the convex hull appear in the permutation in the same order as they appear on the convex hull. The remaining part analyzes the expected time until an optimal solution has been produced from an intersection free tour. This part of the analysis uses that at most inversion operations are sufficient to produce from an intersection free tour an optimal tour. This implies that the (1+1) EA obtains an optimal solution in expected time when the points are placed on an grid and no set of three points is collinear. Here the parameter for the grid directly determines the smallest angle that any set of three non collinear points can have. Note that the runtime bound does not meet the requirement of a fixed parameter evolutionary algorithm.
Afterwards, the ability of evolutionary algorithms to fill in the inner points correctly given that the points on the convex hull are in correct order has been examined. Ant colony optimization [NSN13b] and evolutionary algorithms [NSN13a, SNN14] have been investigated in this context. For ant colony optimization, the crucial aspect to obtain a runtime of is to construct solutions following the order on the convex hull. For evolutionary algorithms, a populationbased algorithm building on a previous approach of Theile [The09] and allowing to build an optimal tour following dynamic programming leads to a fixed parameter evolutionary algorithm with respect to the number of inner points. Furthermore, it is shown in [SNN14] that a simple EA searching for a permutation of the inner points and connecting them to the outer points using the dynamic programming approach given in [DHOW06] leads to a fixed parameter evolutionary algorithm.
3.3 Further Results for Combinatorial Optimization Problems
The early studies of Storch [Sto06] for the maximum clique problem in planar graphs investigated the runtime of RLS and the (1+1) EA with respect to the size of the maximum clique. The fitness (to be maximized) of a search point , representing a selection of nodes, is given by the number of selected nodes if represents a clique and otherwise. The algorithms investigated start with the initial solution which is a feasible solution. For standard bit mutations an expected optimization time of has been shown for (1+1) EA. However, it should be noted that the size of a maximum clique in a planar graph is at most as the complete graph on vertices is not planar. Improved results have been shown in [Sto06] for restart strategies used in RLS and for variants of the EA always deleting an individual with the worst fitness from the population.
The use of problemspecific mutation operators in the (1+1) EA for the maximum leaf spanning tree problem has been investigated in [KLNO10]
. In this work, it has been pointed out that standard bit flip mutations do not lead to fixed parameter evolutionary algorithms, where the parameter is the value of an optimal solution. Edge exchanges that include an edge currently not present in a spanning tree and that remove an edge from the resulting cycle are frequently used for spanning tree problems as they again lead to spanning trees. Using edge exchanges for mutation where the number of edge exchanges is chosen according to a Poisson distribution with expected value
, it has been shown in [KLNO10] that the resulting (1+1) EA is a fixedparameter evolutionary algorithm when taking the value of an optimal solution as the parameter.4 Setting the Parameters of Evolutionary Algorithms
The parameters of an evolutionary algorithm allow to adjust the EA to the problem to be solved and thus to optimize its performance. This is a great feature of EAs, but, at the same time, a difficult challenge [LLM07]. Missing good parameter values often gives a horrible performance. Unfortunately, there is not much general advice on how to set the parameters. The few suggestions in this direction we have, however, have been influenced significantly by theoretical works. In this section, we show how theoretical works have helped to understand how the parameters of EAs influence their performance. Recently, the theory of EAs has also made big progress in understanding and even designing automated ways to find good parameter values.
4.1 Finding Optimal Static Parameter Values (Parameter Tuning)
By parameter tuning we understand the problem (or process) or finding suitable parameter values and then running the EA with these parameters. The parameter values are not changed during the run, so we speak also of static parameter values. For reasons of space, we cannot discuss the whole literature on theoretical results that help tuning EA parameters, and therefore pick the mutation rate in standard bit mutation as the most prominent example. Other parameters that have attracted theoretical research include the parent and offspring population size (see, e.g, [JJW05, Wit06, RS14, DK15, ADFH18]) and the selection pressure (see, e.g., [JS07, Leh10, Leh11, ADY19]). For a discussion on how to set the parameters of estimationofdistribution algorithms, we refer to Section 7.2.3.
The mutation rate is the parameter most discussed in the literature, and for good reason. A too small mutation rate leads to slow a progress because the radius of exploration is small. A too high mutation rate is detrimental because the random choice of the bits to be flipped in average increases the distance from the target solution, and this effect is linear in the mutation rate.
An early established [Müh92, Bäc93] and generally accepted [Bäc96, BFM97] recommendation is to use the mutation rate in standard bit mutation, that is, we generate an offspring by flipping each bit independently with probability . With this choice, the expected distance between parent and offspring is one, so we inherit principles from local search. Different from local search, this mutation operator can leave local optima by flipping more than one bit.
A large number of mathematical runtime analyses shows that often is optimal and thus complements the experimental support for this recommendation (see, e.g., [Och02] and the references therein). For the performance of the EA on OneMax, a mix of rigorous and heuristic arguments already in [Müh92] and then fully rigorously in [GKS99] shows that is asymptotically optimal. For the LeadingOnes benchmark, a rate of was proven to be optimal in [BDN10]. The OneMax result was greatly extended in [Wit13] with a proof that is the asymptotically optimal mutation rate for each pseudoBoolean linear function with nonzero coefficients. In [GW17] it was proven that is the asymptotically optimal mutation rate for the EA when the offspring population size is not too large. The optimality of was also shown for the optimization of longpath functions [Sud13]. For monotone functions, the situation is not fully understood, but again mutation rates around appear to be a good choice. For the runtime of the EA on strictly monotonically increasing functions, a runtime can easily be shown when the mutation rate is for a constant . That mutation rates for larger can lead to exponential runtimes was first shown in [DJS13], the best known value for the constant is [LS18]. In the range around , for a long time only a runtime guarantee of was known for being exactly [Jan07]. A significant progress on this longstanding problem was only made very recently – in [LMS19] an entropy compression argument was used to show that an runtime guarantee holds for all mutation rates , where for some constant .
We note that the above results give some indication that is a good first choice for the mutation rate, but by no means they prove that it always is. Indeed, already in [JW00] an example was constructed such that the EA with any mutation rate that is not needs superpolynomial time with high probability to optimize this problem. In [Prü04], the optimal mutation rates for the EA optimizing hurdle functions with hurdle widths and were shown to be and . This result could have led to the following findings, but apparently its broader implications on mutation rates (in a paper primarily discussing crossover) were not detected. So it was only in [DLMN17] that the optimal mutation rate of the EA on jump functions was shown to be roughly , where is the size of the fitness gap of the jump function. Also, it was shown that a small deviation from the optimal rate, say by a factor of , a constant, leads to a significant increase of the runtime by a factor exponential in .
This result shows that the optimal mutation rate depends strongly on the input instance, that there is no rate that is universally good for all jump functions, and that the price for missing the right rate is significant. This let the authors of [DLMN17] suggest to use a random mutation rate, chosen independently for each mutation from a powerlaw distribution. This heavytailed mutation operator shares with the classic mutation operator the property that a single bit (and more generally, any constant number of bits) is flipped with constant probability. When the powerlaw exponent is above two, then it also shares the property that an expected constant number of bits is flipped. Different from the classic recommendation, however, higher numbers of bits are flipped with larger probabilities. This essentially parameterless operator was shown to give on any jump function a performance of the EA that differs from the one with instanceoptimal mutation rate by only a small factor polynomial in . Heavytailed mutation operators proved to be successful in several other discrete optimization problems [FQW18, FGQW18b, FGQW18a, WQT18, ABD20a, ABD20b, AD20]. From a broader perspective, this line of work is an example showing that theoretical work not only can help understanding evolutionary algorithms, but it can also propose new operators and algorithms.
4.2 Dynamic Parameter Settings (Parameter Control)
Instead of trying to find a good parameter setting before starting the EA and sticking to this choice throughout the run of the EA, one could also think of optimizing the parameters during the run of the algorithm. This sophisticatedlooking idea is called parameter control and turns out to be less frightening than it appears at first.
Indeed, the decision space (and thus also the opportunity to take an unsuitable decision) is much larger now – in principle, we could choose different parameter values in each iteration – but there are several powerful ways to overcome this difficulty. The advantage of parameter control is that we can react on the performance observed so far. This has two particularly positive consequences: (i) The need for finding good parameter values before the start of the algorithm, based on a maybe only vague understanding of the problem to be solved, is reduced since a suboptimal initial choice can be corrected. (ii) In the common situation that different parameter settings are optimal during different stages of the optimization process, we have the chance to use the optimal parameters for each stage (whereas a static choice would need to find a suitable tradeoff).
It is clear that the large space of different parameter settings for each iteration renders it unlikely to find the absolutely best dynamic choice of the parameters. However, it turns out that often very simple successbased or learningbased approaches lead to a very good performance, and often one that is better than the best static parameter setting. This is confirmed in many practical applications, see, e.g., [KHE15], but also in now a decent number of theoretical works.
The theoretical superiority of dynamic parameter settings over static ones was already demonstrated in [DJW00] (see also [JW06] for an extension of this work), albeit for a simple algorithm with a simple timedependent parameter choice optimizing an artificial problem. Nevertheless, this result has rigorously proven that, in principle, dynamic parameter choices can efficiently solve problems where classic static choices would badly fail. Interestingly, the idea of timedependent mutation rates was recently used again [RW20] to help EAs leaving local optima.
It took ten years until dynamic parameter choices could be shown superior also for classic benchmark problems. The first such work [BDN10] (see also [Doe19a, Section 2.3] for an extension) showed that a constantfactor runtime gain can be obtained from a fitnessdependent choice of the mutation rate when optimizing the classic LeadingOnes benchmark via the EA. Again it took some time until in [BLS14], a superconstant runtime gain (of order ) from a dynamic parameter setting was shown for the EA optimizing OneMax. Other fitnessdependent parameter choices were discussed in [DDE15, DDY20]. A main problem with fitnessdependent parameter settings (or more generally speaking, parameter choices that depend on the current state of the algorithm) is that is needs a very good understanding of the problem to define a suitable functional dependence of the parameter value on the algorithm state. For the two examples from [BLS14, DDE15], it appears unlikely that without a mathematical analysis someone would have found the optimal functional dependence. Finding suboptimal statedependent parameter values that beat the best static values appears more realistic, but this remains a challenging task requiring a lot of expert knowledge.
Fortunately, there are dynamic parameter settings that need much less expertise. Generally speaking, these observe how the algorithm performs with the current parameter values (and sometimes also the values used in a longer history) and based on this try to adjust the parameter values to more profitable values. The easiest of these onthefly parameter choices are successbased multiplicative parameter updates. Assume that we have a parameter for which we suspect that an increase increases the chance to find an improvement, but this also increases the computational cost of one iteration. Then increasing the current parameter value after each iteration without improvement and decreasing it after each iteration with improvement is a simple way to try to move the parameter value into a profitable region. Exactly this was suggested for the offspring population size of the EA in [JJW05] and was rigorously analyzed in [LS11], where an asymptotically optimal speedup of the parallel runtime (number of iterations, ignoring the different costs of the iterations) was shown. The same basic idea was shown to give a (small) asymptotic improvement of the total runtime (number of fitness evaluations) for the GA optimizing OneMax [DD18] and certain random SAT instances [BD17].
The usual way to change the parameter value is multiplying or dividing by suitable constant factors. In [LS11], simply the factor was used, and it is clear that any other constant factor would have given the same asymptotic runtime. In general, as observed in [DD18], smaller update factors can be the safer choice, and also the relation of the factors used in case of success and no success can be important. In [DDL19]
, a detailed analysis how the choice of these hyperparameters influences the runtime of the
EA with dynamic mutation rate on the LeadingOnes function was conducted. Other theoretical works on multiplicative parameter updates include [DDK18] for multivalued decision variables, [MS15] for migration intervals of island models, and [DLOW18] for the learning period of a hyperheuristic. We note that the results just described are the first examples of successbased parameter updates in discrete evolutionary optimization. In continuous optimization, a multiplicative update of the step size known as onefifth rule was already proposed in [Rec73].Multiplicative update rules work best if there is a simple monotonic influence of the parameter on the success, e.g., as seen for the offspring population size of the EA. Since such a simple relation is harder to find for the mutation rate in the EA, a different successbased scheme was developed in [DGWY19]. Here half of the offspring are generated with twice the current rate, the other half with half the current rate. The mutation rate is then updated to the rate the best offspring was generated with (however, only with probability a half, with the other onehalf probability the new rate is chosen randomly from the two alternatives). This mechanism was shown to let the EA optimize OneMax in asymptotically the same time as with the optimal fitnessdependent mutation rate developed in [BLS14].
A second way to go beyond multiplicative updates, and to additionally take more stable decisions, was proposed in [DDY16]. Here for a small number of possible values of a parameter, a timediscounted estimate of the effectiveness of this parameter value was computed. In each iteration, with large probability, the bestperforming value was used (exploitation) and with small probability a random one of the other values was used. With the right choice of the hyperparameters, this mechanism was shown to arbitrarily well approach the optimal mutation strengths of the EA optimizing OneMax that were computed in [DDY20].
The most generic way to let an EA optimize its parameters itself is selfadaptation, which means that the parameters are made part of the encoding of the solution candidates and thus become subject to variation and selection. This idea goes back to [Bäc92]. Taking the mutation rate as example, one appends an encoding of the mutation rate to the representation of the solution candidates. When mutating such an extended individual, one first mutates the mutation rate encoded in the extended individual and then, with the new rate, the remainder of the individual. The hope is that the suitability of a rate is visible from a higher fitness of the resulting individuals, and that the selection mechanisms of the EA bring these individuals (and thus the good mutation rate) forward in the population. While this way of adjusting parameters is clearly more natural for an EA than parameter adjustment mechanisms outside the evolutionary process, only two rigorous results supporting the usefulness of selfadaptation in discrete evolutionary computation have been published. In a first proofofconcept work [DL16], an example is constructed that shows that selfadaptation can be useful. In this example, only two different mutation rates are available and it is assumed that the whole initial population starts in a particular search point. In [DWY18a], the EA with selfadapting mutation rate is analyzed. With the hyperparameters suitably chosen, it can evolve sufficiently good mutation rates to obtain asymptotically the same performance on OneMax that was previously obtained with the optimal fitnessdependent setting [BLS14] and the twopopulation selfadjustment [DGWY19].
4.3 The Future of Parameter Research
The existing results show that we are now able to analyze a variety of static and dynamic parameter choices with a precision high enough to clearly distinguish good from bad choices. Some of these works not only analyzed existing algorithms or parameter adjusting mechanisms, but also suggested new approaches. Clearly, as true for all theoretical works, the algorithms and problems that were regarded are much simpler than those occurring in a practical application of EAs. To what extent the recommendations obtained from these simple settings generalize to more realistic ones is a crucial question which can only be answered in a collaboration between theoretical and applied researchers.
From the theory perspective, the following questions appear timely and interesting.

Interaction of parameters: So far, the vast majority of runtime analyses varies at most one parameter of the algorithm. Experience from practice shows that the interaction of several parameters is even harder to understand. So more runtime analyses discussing several parameters at once are clearly needed. Also, to the best of our knowledge, there is currently no theoretical work regarding two or more independent heavytailed parameters or selfadjusting or selfadaptive settings of two or more parameters.

Selfadaptation: The most natural way to let an algorithm optimize its parameters is selfadaptation, where the parameters are integrated into the evolutionary cycle. So far, only very little theoretical advice exists how to successfully control parameters via selfadaptation. Here clearly more work is required.

Connections with machine learning: The area of machine learning has made tremendous progress in the last decades. Given that EAs are iterative algorithms in which often the state of the system changes only little in each iteration, one could envisage that dynamic parameter choices can profit from ideas and concepts borrowed from machine learning. While some ideas used in EAs can be related to similar ideas in machine learning, it seems to us that the full power of this connection has not yet been exploited.
5 Analysis of Evolutionary Algorithms in Dynamic and Stochastic Environments
Dynamic and stochastic environments play a key role in realworld applications as information is often uncertain and circumstances change over time. Evolutionary algorithms have the ability to deal with changing circumstances and perform well in noisy environments which makes them well suited for dealing with dynamic and stochastic problems. The area of runtime analysis has initially focused on simple toy problem in dynamic and stochastic settings. Again the function OneMax has played a crucial role to get initial insights. An important aspect in the context of dynamic optimisation is how often and how drastic a function changes over time. We will describe important results for settings where the function or the constraints of a given problem change dynamically. Furthermore, we will summarize results where the fitness evaluation is impacted by noise and point out different results according to different noise models studied in the literature. Additional investigations regarding dynamic and stochastic constraints in the context of submodular optimization are summarized in Section 6.
5.1 Dynamic Benchmark Functions
Runtime analysis for dynamically changing functions in discrete search spaces have been started by Droste [Dro02, Dro03]. He investigated a dynamic variant of the classical OneMax problem on binary strings. In the first dynamic setting, one randomly chosen bit is flipped in each iteration with probably . Droste [Dro02] showed that the expected optimization time of the (1+1) EA is polynomial iff . In the case where each bit is flipped in each iteration with a given probability investigated in [Dro03], the runtime becomes superpolynomial if and is polynomial if .
These investigations have ten years later on be revisited using drift analysis and generalized to the case where each element is not binary but can take on different values [KLW15b]. A comparison on the ability of simple evolutionary algorithms and ant colony optimization approaches for dealing with dynamic fitness functions has been carried out in [KM12, LW16]. These studies show that ant colony optimization can beat evolutionary algorithms due to their ability of adjusting slowly to changes in the fitness functions. Investigations of parallel evolutionary algorithms using island models carried out in [LW18] for the MAZE function, introduced in [KM12], show that infrequent migration of individuals is necessary for dense models where as infrequent migration becomes less necessary when working with sparse topologies in the island model.
5.2 Dynamic Combinatorial Optimization Problems
There are also some results on classical combinatorial optimization problems in the dynamic setting. Lissovoi and Witt [LW15] have investigated ACO algorithms and shown how the number of ants can impact different types of changes that can be tracked over time. They also gives example of dynamic oscillations that can not be tracked with a polynomial number of ants. Dynamic makespan scheduling for two machines has been investigated by Neumann and Witt [NW15]. They have studied dynamic settings where solutions of small discrepancy of the two machines has to be recomputed. The results show that a worst case discrepancy of where is an upper bound on the maximal job length can be maintained. Furthermore, better upper bounds on the runtime and lower discrepancies are shown for the case where the processing times of the jobs change randomly.
Dynamic variants of the minimum vertex cover problem have been considered in [PGN15, PRN20]. Following the edgebased encoding for the minimum vertex cover problem introduced in [JOZ13], the problem formulation makes use of the dual formulation of the problem in order to represent solutions. In [PGN15], the expected time to recompute approximation when edges are added or removed has been studied and improved results have been presented in [PRN20].
Dynamic settings of the classical graph coloring problem have been investigated in [BNPS19]. Here, in particular bipartite graphs have been studied and the necessity of complex mutation operators has been revealed even if there are only slight dynamic changes to the graph structure. These investigations have recently been extended in [BNPS20] and it has been shown that a dynamic setting where edges are presented to the algorithm in an iterative way can provably lead to better optimization times than presenting the algorithm with the whole input graph at once.
5.3 Noisy Problems
Studies on the runtime behaviour of evolutionary computing techniques for discrete search spaces involving noisy objective functions have again been started by Droste [Dro04] who analyzed the (1+1) EA on a noisy version of OneMax. He studied a prior noise model. In this case, some bits of a solution are flipped prior to the fitness valuation. The studies considered flipping each bit with probability prior to fitness evaluation and Droste showed that the (1+1) EA can still obtain the optimal solution for OneMax in expected polynomial time if whereas the expected optimization time becomes superpolynomial if . In general, investigations can be separated into ones investigating prior noise as described above and posterior noise.In the case of posterior noise, the search is evaluation on the solution but noise is added afterwards to the fitness value . Gießen and Kötzing [GK16] build on this initial study by Droste and extended the studies to populationbased evolutionary algorithms and also used prior and posterior noise. Results for prior bitwise noise for the classical benchmark functions OneMax and LeadingOnes have been obtained in [BQT18, QBJT19]. Additional and improved results including an example where noise helps have been provided by Sudholt [Sud18] and estimation of distribution algorithms (see Section 7) have been studied for OneMax in [FKKS17]. A method that can be used for the analysis of dynamic and noisy fitness functions has been developed in [DNDD18]. Furthermore, the tradeoff between reducing noise through resampling and the computational cost of resampling has been investigated by Friedrich et al. [FKQS17]. The authors investigated classical evolutionary algorithms, estimation of distribution algorithms and ant colony optimization for OneMax and the case of additive posterior Gaussian noise.
In terms of classical combinatorial optimization problems, Sudholt and Tyssen [ST12] investigated the stochastic singledestination shortest path problem and have pointed out settings where ant colony optimization is able to solve this problem in expected polynomial time or obtain a good approximation in expected polynomial time. These investigations have been extended in [DHK12] where a slight modification of the previously considered ant colony optimization approach has been analyzed and shown that this modified approach finds shortest path lengths efficiently although it does not necessarily converge. Furthermore, stochastic constraints in form of chance constraints which require that stochastic constraints can only be violated with a small probability have been investigated recently (see Section 5.4 and 6.3).
5.4 Combinatorial Optimization Problems with Dynamic and Stochastic Constraints
Dynamic constraints reflect the change in resources to solve a given problem. This is often a crucial aspect in many planning problems where resources such as trucks and trains might become unavailable due to failures or become available (again) after maintenance. Considering dynamic constraints, the objective function to be optimized is often assumed to be fixed and only changes to the constraint are considered. The simplest example is the maximization of a linear function subject to a uniform constraint which limits the number of elements to be at most . The first runtime analysis in this area considered the case where the bound changes to and the question is how long an evolutionary algorithm needs to recompute from an optimal solution for a given bound an optimal solution for the updated bound . The (1+1) EA and simple evolutionary multiobjective algorithms have been studied in [SSF19]. The multiobjective formulations enable to efficiently deal with constraint bound changes and this leads to significantly better experimental results on a wide range of knapsack instances as shown in [RNN20] if the magnitude and frequency of change is not too large.
Chance constraints model constraints that are impacted by some noise of the given components and the goal is to optimize a given function under the condition that the constraint is violated with probability at most , where is usually a small value, e.g. . Evolutionary algorithms for the chanceconstrained knapsack problem have by studied from an experimental perspective by Yue et al. [XHA19, XNN20]. Furthermore, Assimi et al. [AHX20] investigated evolutionary multiobjective evolutionary algorithms for the dynamic chanceconstrained knapsack problem where the constraint bound for the knapsack dynamically changes over time through experimental studies. A first runtime analysis for problems with chance constraints has been carried out by Neumann and Sutton [NS19] for special instances of the knapsack problem. It shows that even very simple linear functions with a simple linear constraint can lead to local optima with large inferior neighbourhoods that may make it hard for the (1+1) EA to produce an optimal solution.
Important results on evolutionary algorithms for the optimization of submodular functions under dynamic and stochastic constraints have been obtained recently and are summarized in Section 6.3. Furthermore, a more comprehensive and technical survey on the theory of evolutionary computing in dynamic and stochastic environments can be found in [RPN18].
6 Submodular Optimisation
Submodular functions play a keyrole in the area of optimization as many real world problems can be stated in terms of a submodular function as many problem face a diminishing return when adding additional components to a solution. The recent book by Zhou et al. [ZYQ19] is given a very comprehensive presentation on submodular optimization by evolutionary algorithms solving a wide range submodular problems in the areas of optimisation and machine learning.
We consider the following setting. Given a set of elements, the goal is to maximize a function that maximizes subject to a given set of constraints. Submodular functions are usually considered in terms of marginal value when adding a new element. We denote by the marginal value of with respect to . A function is submodular iff for all and . Furthermore, a function is called monotone iff for .
The first investigations in terms of runtime behaviour of evolutionary algorithms for submodular functions, we are aware of, have been carried out by Rudolph [Rud97] in the 1990s. More then 15 years later this research area has been restarted by Friedrich and Neumann [FN14] and has since then gained significant attention. The research in the context of static optimisation can be grouped with respect to the type of objective functions and the type of constraints that are considered. In terms of objective functions, it is usually differentiated between monotone and nonmonotone submodular functions. Furthermore, the submodularity ratio plays a crucial role when broadening the class of functions to functions that are not submodular. This ratio measures how close a function is to being submodular. The submodularity ratio of a given function is defined as
Note that if is submodular then holds. The other important component in these investigations are the type of constraints that are considered. Constraints are usually of the type , where assigns a non negative cost to each set of elements and is a given constraint bound. This type of constraints includes the case of a simple uniform constraints where holds and limits the number of elements that can be included in a feasible solution by . The maximization of a monotone submodular function is already NPhard and can be approximated within a factor of by a simple greedy algorithm [NWF78]. More complex constraints involve partition or matroid constraints which are given in form of linear functions. Complex constraints considered include cost values that can only be approximated, i.e. involving NPhard routing problems. Then the approximation obtained for the submodular function depends on the type of objective function as well as the ability to calculate the cost of the considered constraint. In the following, we summarize some of the main results in this currently very active research area.
6.1 Monotone Submodular Functions
Optimal solutions for monotone submodular functions with a cost constraint can often be approximated well by simple greedy algorithms (see [KG14] for a comprehensive survey).
Such greedy algorithms start with the empty set and add in each iterations an element with the the largest marginal gain
that does not violate the constraint. The algorithm stops if no element can be added without violating the constraint bound.
Variants of GSEMO (see Algorithm LABEL:alg:paramcomplex:gsemo) have been widely studied in the context of optimzing submodular functions. The initial analysis carried out in [FN14] considered the maximization of monotone submodular functions with different types of constraints. After this GSEMO has been widely studied in the context of submodular optimization under the umbrella of Pareto Optimization which formulates a given constraint optimization problem as a multiobjective problem by establishing an additional objective based on the considered constraint. Such approaches have been widely used already before this in the context of runtime analysis of GSEMO. Solving singleobjective problems by multiobjective formulations is a wellknown concept in the evolutionary computation literature and has been studied from a practical and theoretical perspective since mid of the 2000s [Jen04, NW06, BFH09].
For simplest case of a uniform constraint where , GSEMO selects in each step an element with the largest marginal again with respect to . Friedrich and Neumann [FN14] have shown that GSEMO produces a approximation for monontone submodular functions with a uniform constraint in expected time where . For monotone submodular functions with matroid constraints, local search and simple singleobjective evolutionary algorithms such as the classical (1+1) EA are able to obtain good approximation results. It has been shown by Lee at al. [LMNS09] that local search introducing at new elements and removing at most elements is able to obtain a approximation in polynomial time if and are constants. This result has later on been used to show that the (1+1) EA is able to obtain the same approximation guarantee in expected time . The crucial part of the proof is result from [LMNS09] which shows that every solution for which there is no in the defined neighborhood with is already a approximation.
Further investigations lead to a wide range of results for GSEMO on various submodular problems with cost constraints. The algorithm GSEMO is often called POMC (or similar) in such articles and the approaches are referred to as Pareto optimization. However, usually the difference only lies in the formulation of the objective functions to formulate the constrained submodular problems as a multiobjective optimisation problem.
An important result covering a wide range of monotone functions for a broad class of cost constraints has been obtained by Qian et al. [QSYT17]. They investigated monotone functions in terms of submodularity ratio and general cost functions including ones for which it is hard to obtain an optimal solution exactly. Their theoretical results make use of proof ideas used for an adaptive greedy algorithm and show that a variant of GSEMO called POMC is able to obtain the same approximation guarantee in expected pseudopolynomial time. The expected runtime may be exponential with respect to the given input here if both the submodular function and the cost function can take on exponentially many values. In this case, the population size of GSEMO may become exponential during the run. More precisely, the have shown that POMC obtains a approximation, is the submodularity ratio, for a relaxed cost constraint (instead of B) where depends on how well the given cost constraint can be approximated. Note that this setting includes problems where the cost of a solution may be hard to compute, i.e. for a selection of items it could be an approximation of a minimum Traveling Salesperson tour. The experimental results show that POMC clearly outperforms the adaptive greedy approach if the evolutionary algorithm is given a sufficient large number of fitness evaluations.Recently, an evolutionary multiobjective algorithm called EAMC has been introduced in [BFQY20] which obtains the same worstcase approximation ratio as POMC in expected polynomial time if the submodularity ratio of the given problem and used in the algorithm. However, EAMC usually performs worse than POMC on important benchmark problems.
Subset selection has also been investigated in the context of sparse regression. Here the submodular ratio of the underlying function to be optimized plays crucial role for the approximation quality obtained. Again a variant of GSEMO called POSS [QYZ15] achieves in expected polynomial time the same approximation quality as a greedy approach called forward regression [DK11], namely a solution with . Furthermore, POSS outperforms forward regression and other simple heuristics in experimental investigations in terms of solution quality when giving it a sufficient amount of time to improve solutions during the evolutionary optimisation process.
6.2 Nonmonotone Submodular Functions
For symmetric functions which are not necessarily monotone and have matroid constraints. Evolutionary algorithms and local search approaches can increase the function value by local operations to obtain a good approximation. Lee et al [LMNS09] have shown that if a solution the value of a solution can not be increased by a factor of at least changing at most elements, then is a approximation. The series of such local improvements requires that the algorithm obtains a solution of value at least . Such a solution can be obtained from the empty set by adding the single element with the largest function value. Consequently local search algorithms building on such a solution and exchanging at most elements obtain a solution with the stated approximation quality in polynomial time [LMNS09]. It has been shown that GSEMO obtains a approximation in expected time . The proof analyzes the process until a solution with is obtained and the required number of local improvements until a solution of the stated approximation quality is obtained.
In their recent work, Qian et al. [QYT19] give other major results which are broadening the setting of previous investigations. The considered an evolutionary multiobjective algorithm called GSEMOC which differs from GSEMO by producing from the offspring a second offspring which is the complement of the first offspring. The selection step of GSEMO is then applied to both and . The authors first showed that for the case of nonmonotone submodular functions without any constraint, GSEMOC is able to obtain a approximation in expected time . For monotone submodular functions, , where holds for any and , and a uniform constraint with bound , they showed that GSEMOC achieves a solution with in expected time which generalizes the result given in [FN14] to a wider range of functions by taking their closeness to monotonicity into account. Similar approximation results also hold for GSEMOC when considering approximately submodular functions, i.e. for functions for which a submodular function exists such that for all , holds. The authors showed that suitable approximation can also be obtained for a wider range of functions with a cardinality constraint in expected time . Specifically, they obtained results that depend on to the submodularity ratio of the problem and investigated functions that are approximately submodular.
Functions with bounded curvature under partition matroid constraints have been investigated in [FGN19]. The results include the case of nonmonotone submodular functions and approximation guarantees have been shown for the generalized greedy algorithm. These investigations have recently been extended by Do and Neumann [DN20a] to the evolutionary multiobjective algorithm GSEMO which is able to guarantee the same approximation quality as greedy but usually outperforms greedy in practice.
6.3 Dynamic and Stochastic Submodular Functions
Recent studies extended the investigations for monotone submodular functions to problems with dynamic constraints as well as constraints involving stochastic components. Roostapour et al. [RNNF19] investigated the setting of general cost constraints where the constraint bound changes over time. Generalizing the results of Qian et al. [QSYT17] which are summarized in Section 6.1, they have shown that the evolutionary multiobjective approach POMC computes a approximation for every budget , . Furthermore, they have shown that if is increased to , then a approximation for every , is obtained in pseudopolynomial time. In contrast to this, it has been pointed out in [RNNF19] that simple adaptations of the generalized greedy algorithm are not able to maintain good approximations when dynamic changes are carried out. Furthermore, POMC is able to learn the dynamic problems over time which gives it significant advantages over the greedy approaches as shown in comprehensive experimental investigations [RNNF18].
Recently, the investigations in the area of submodular optimisation have also been extended to stochastic constraints. Chance constraints play an important role in stochastic settings. These model situations where components of a constraint are stochastic and the goal it to optimize a given submodular objective functions such that the probability of violating a given constraint bound is at most . Doerr et al. [DDN19]
investigated greedy algorithms for the optimization of monotone submodular functions for two settings. In the first setting, the stochastic weights are identically and independently uniformly distributed within a given interval
, , where models the uncertainty of the items. In the second setting each element has its own expected weight and is chosen independently of the others and uniformly at random in , . The investigations have recently been extended by Neumann and Neumann [NN20] to GSEMO and it has been shown that this algorithm is able to obtain the same approximation guarantee as the greedy approach in expected polynomial time in the case of identically and independently uniformly distributed weights. For the second setting, the same approximation guarantee as the one obtained for the greedy approach is obtained in expected pseudopolynomial time. Furthermore, experimental investigations carried out for the influence maximization problem in social networks and the maximum coverage problem show that GSEMO significantly outperforms the greedy approach. A comparison of GSEMO to a standard setup of NSGAII reveals that GSEMO is also often outperforming NSGAII for the investigated settings which suggests that the ability of GSEMO to construct solutions in a greedy fashion is also crucial for the success of the algorithm in practice.7 Theory of EstimationofDistribution Algorithms
Estimationofdistribution algorithms (EDAs) are a more recent class of evolutionary algorithms (EAs). As a main difference to classic EAs, they to not evolve a population (that is, a finite set of solution candidates), but a probabilistic model of a solution candidate (that is, a probability distribution over the search space). Whereas a traditional EA selects individuals from a parent population, creates from them offspring via mutation and crossover, evaluates the offspring, and based on this evaluation selects from parents and offspring the next parent population, the EDA samples individuals from the current probabilistic model, evaluates them, and based on this evaluation defines the next probabilistic model. When viewing a parent population of a classic EA as probabilistic model (uniformly distributed on the individuals of the population), one can interpret populationbased EAs as particular EDAs, but it is clear that the probabilistic models of EDAs are much more expressive than models building on finite populations. The obvious hope is that this richer class of algorithms contains better optimizers. However, there is also the additional fantasy that the probabilistic model evolved by an EDA can give insights beyond the good solutions that can be sampled from it.
Most EDAs were defined in the 1990s, first in 1993 in an unpublished work [JBS93] by Ari Juels, Shumeet Baluja, and Alistair Sinclair (see [Lob07]) proposing the
equilibrium genetic algorithm
. While clearly containing the right ideas, this paper was never published and this algorithm is little known. Acknowledging the joint work with Ari Juels, Shumeet Baluja [Bal94] proposed a very similar algorithm called populationbased incremental learning (PBIL). As an important special case of it, Mühlenbein and Paass [MP96] two years later suggested the univariate marginal distribution algorithm (UMDA). In 1999, Harik, Lobo, and Goldberg [HLG99] proposed the compact genetic algorithm (cGA). These and several other EDAs found numerous successful applications in the following years, see, e.g., the surveys [HP11, LL02, PHL15].First attempts to understand EDAs via theoretical means soon followed, starting – as often – with convergence results such as [HR97]. We note, however, that many of these very early results work with simplifying assumptions such as infinite population models and thus are not fully rigorous in the strict mathematical sense. In a series of works, Shapiro [Sha02, Sha05, Sha06] analyzed how the parameters of EDAs influence the effect of genetic drift. We discuss this central topic in more detail in Section 7.2.3.
The first rigorous runtime analysis for an EDA was presented by Droste at GECCO 2005 (journal version [Dro06]). Chen, Lehre, Tang, and Yao [CLTY09] exhibited an artificial example problem which is easily solved by the UMDA, but for which the EA with any mutation rate needs exponential time to find the optimum. In [CTCY10], Chen, Tang, Chen, and Yao discussed the use of frequency boundaries to prevent premature convergence. After these early works, it took another five years without theoretical works on EDAs until this area gained significant momentum in 2015–2016 with works like [DLN19] (conference version at GECCO 2015), conducting a runtime analysis of the UMDA on OneMax and LeadingOnes, [FKKS17] (conference version at ISAAC 2015) on the robustness of EDAs to noise, [SW19] (conference version at GECCO 2016) on how the update strength influences the runtime of the cGA, and [FKK16] pointing out that the main known EDAs are balanced, but not stable (that is, subject to genetic drift). These works generated a broad interest in theoretical analyses of EDAs, resulting is a large number of strong papers by a decent number of different authors. We refer to the recent survey [KW20a] for more details.
7.1 The Compact Genetic Algorithm
We now describe the compact genetic algorithm (cGA), which will serve as central example in this section. Other EDAs such as the UMDA or PBIL are substantially different, but appear to have similar strengths and challenges, so expecting similar results for these is a reasonable rule of thumb. However, we only concentrate on EDAs for discrete optimization problems here and we expect very different results in the continuous world. For reasons of simplicity, we only regard pseudoBoolean problems, that is, the optimization of functions .
The compact genetic algorithm (cGA) was proposed by Harik, Lobo, and Goldberg [HLG99]. Being a univariate EDA, it develops a probabilistic model described by a frequency vector
. This frequency vector determines the following probability distribution on the search space
. If is a search point sampled according to this distribution – we write to indicate this – then we have independently for all . In other words, the probability that equals some fixed search point is .In each iteration, the cGA updates this probabilistic model by sampling two search points , computing their fitness, sorting them, that is defining if is at least as fit as and otherwise, and updating the frequency vector to , capped into the interval , that is, with entries below zero replaced by zero and entries above one replaced by one. This definition ensures that when and differ in some bit position , the th frequency moves by a step of into the direction of (but not below zero and above one). The hypothetical population size , often also denoted by , is an algorithm parameter that controls how strong this update is. To avoid a premature convergence, one often works with the frequency boundaries and , that is, one caps the new frequency vector into the interval instead of .
This iterative frequency evolution is pursued until some termination criterion is met. Since we aim at analyzing the time (number of iterations) it takes to sample the optimal solution (this is what we call the runtime of the cGA), we do not specify a termination criterion and pretend that the algorithm runs forever.
algocf[htbp]
7.2 Central Results
In this section, we discuss three main insights which the theoretical analysis of EDAs has produced. For reasons of space, we point out two of them only briefly, namely that EDAs can perform well in noisy optimization and that they can cope well with local optima, and then discuss in detail how to set the parameters of EDA as this might the biggest obstacle in successfully using EDAs.
7.2.1 EDAs Can Cope Well with Noise
In their remarkable work [FKKS17], Friedrich, Kötzing, Krejca, and Sutton exhibit that the cGA is extremely robust to noise. More precisely, they show that the cGA with a suitable parameter choice can optimize a OneMax
function subject to additive normally distributed noise in a runtime that only polynomially depends on the variance
of the noise. As they also show, such a performance cannot be obtained with many classic EAs. The reason for this robustness is the cautious update of the probabilistic model in each iteration (as opposed to the “drastic” alternatives of a classic EA, rejecting an offspring or keeping it and discarding some other individual). This caution of the EDA implies that a single wrong evaluation of a search point only has a small influence on the future run of the algorithm. In the only other study on how EDAs cope with noise, Lehre and Nguyen [LN19b] show that the UMDA with suitable parameter choices can optimize the LeadingOnes problem in time also in the presence of constantprobability onebit prior noise. We note that a strong robustness to noise was previously found in antcolony optimizers [DHK12, FK13, ST12], which bear some similarity to EDAs.7.2.2 EDAs Can Cope Well with Local Optima
Another difficulty for many EAs are local optima. Once the population of the EA is concentrated on the local optimum, it is difficult to leave this local optimum. As Hasenöhrl and Sutton [HS18] (see also [Doe19c]) show, the larger sampling variance of the cGA (in the regime without genetic drift) enables the algorithm to leave local optima much faster than many classic EAs. More specifically, Hasenöhrl and Sutton show that the cGA can optimize a jump function with jump size in time , whereas many mutationbased EAs need time .
7.2.3 Genetic Drift and Optimal Parameter Choices
Both the result on noisy optimization and the one on local optima indicate that EDAs can have significant advantages over classic EAs. For reasons of brevity, we nevertheless omit further details and now turn to an important topic where a large sequence of works together have greatly increased our understanding, namely how to choose the parameters of EDAs and what is the role of genetic drift in EDAs.
While choosing optimal parameters for EAs is never easy, for many classic EAs a number of easy rules of thumb have been developed. For example, for mutationbased EAs the general recommendation to use standardbit mutation with mutation rate often gives reasonable results (though [DLMN17] suggests that this impression is caused by an overfitting to unimodal problems). For EDAs, such general rules that are true over different classes of problems appear to be harder to find. From a large number of theoretical works, we now understand quite well why and we also have a number of different solutions to this problem.
The main challenge is choosing an appropriate speed of adapting the probabilistic model. If this speed of adaptation is low, then it simply takes long to change the initial, usually uniform, model into a model that samples good solutions with reasonable probability. However, if the speed of adaptation is high, then the small random signals stemming from the random choices in the sampling of solutions are overinterpreted and the model is quickly adjusted to an incorrect model. When an EDA without frequency boundaries is used, this means that the model has (at least partially) converged to an incorrect model without the possibility to ever return. With frequency boundaries, there is still the change to revert to a good model, but practical experience and theory shows (i) that this can take long and (ii) that usually the EDA continues to work with degenerate models and thus, to some extent, imitates classic EAs (and consequently does not profit from the more general modelbuilding ability). The effect that sampling frequencies without a justification from the fitness function move to boundary values is known as genetic drift.
Since genetic drift can lead to significant performance problems and since the risk of encountering genetic drift via unfortunate parameter choices is high, the question how to avoid genetic drift is, explicitly or implicitly, a common theme of almost all theoretical works on EDAs. Shapiro’s very early works [Sha02, Sha05, Sha06] discussed this question explicitly, Droste’s first rigorous runtime analysis regarded how the cGA optimizes OneMax only when the update strength is for some constant , a parameter regime in which the cGA with high probability finds the optimum of OneMax in a way that never a sampling frequency goes below , that is, without encountering genetic drift. For reasons of space, we shall not describe in detail the whole history of understanding genetic drift of EDAs, but present immediately the final result only mentioning that both explicit investigations of genetic drift like [Sha02, Sha05, Sha06, FKK16, DZ20b] and the insights gained from many runtime analyses like [Dro06, DLN19, LN17, SW19, Wit19, KW20b, LSW18, HS18, Doe19c, Doe19b] paved the way towards this result.
Before discussing how to avoid genetic drift, let us quickly describe what is known on the danger of genetic drift. A first indication that genetic drift could be dangerous can be derived from the positive results – the majority of the proven upper bounds for runtimes of EDAs only apply to regimes in which there is provably no genetic drift, and in fact, most proofs heavily exploit this. Rigorous proofs that genetic drift can lead to performance losses are much more rare and appeared only very recently, owing to the fact that lower bound proofs for EDAs are often very difficult. In their deep analysis [LSW18], Lengler, Sudholt, and Witt showed that the cGA with needs time to optimize OneMax and the proof of this result shows that genetic drift is present. For , a sufficiently large constant, the cGA only needs time and here no genetic drift occurs [SW19]. A more drastic loss from genetic drift, albeit on an artificial example problem, was observed in [LN19a, DK20c]. Lehre and Nguyen [LN19a] define the deceivingleadingblocks (DLB) problem and show that the UMDA with needs time exponential in to find the optimum. By [DZ20b], in this parameter regime genetic drift is encountered when the runtime is . In [DK20c], it is shown that the UMDA with can optimize the DLB problem in time by profiting from the fact that now there is no genetic drift. A few experimental results also discuss the influence of genetic drift on the performance of an EDA, e.g., Figure 3 in [KW20a] shows the runtime of the UMDA on OneMax and Figure 1 in [DZ20a] shows the runtimes of the cGA on OneMax, LeadingOnes, jump functions and the DLB problem. These results show a mild negative impact of genetic drift in the two OneMax experiments, a stronger impact for LeadingOnes, and a drastic impact for jump and DLB.
We now discuss how to predict and avoid genetic drift. A good way to measure genetic drift is by regarding a fitness function with a neutral bit, that is, a bit position that has no influence on the fitness. This might be overly pessimistic, since for such a bit the risk that the sampling frequency approaches an unwanted boundary value might be higher than for a bit with strong influence on the fitness, but (i) a pessimistic view cannot be wrong here as a slightly too weak model update strength only slightly increases the runtime, whereas genetic drift as just seen can be detrimental, and (ii) the results just described show that the estimates from regarding neutral bits, for these examples, cannot be far from the truth.
The up to now most complete answer to the question of genetic drift was given in [DZ20b], as said, a work that would not exist without the long sequence of previous works named above. We discuss this result in detail for the cGA and note that similar results are true for the UMDA and PBIL.
Theorem 4.
Let . Assume that the th bit of is neutral, that is, for all with for all . Consider optimizing via the cGA with hypothetical population size using the frequency range for some . Denote by the frequency vector resulting from the th iteration.

Let . Then .

Let be the first time the th frequency leaves the interval of the frequency range. Then .

For all and , we have .
In very simple words the above result states that if we run the cGA for less than roughly iterations, then we do not encounter genetic drift, whereas after more than roughly iterations, genetic drift is likely to occur.
The tail bound (3) together with a simple union bound admits more precise guarantees, e.g., the following two formulations.

If our aim is to run the cGA for iterations on some pseudoBoolean function of dimension , then by taking we can ensure that with probability at least no neutral bit has its frequency leave the interval within these iterations.

When is given, the probability that within iterations a neutral frequency leaves the interval is at most .
We note without further details that similar statements hold for bits which are not neutral, but which have a preference for a particular value , that is, where changing the bitvalue to can never decrease the fitness. Here the above statements hold for the undesired events that the frequency of this bit approaches the wrong boundary . We refer to [DZ20b] for a precise statement of this result. This extension allows to determine good values for the hypothetical population size for simple test functions like OneMax or LeadingOnes: If we run the cGA on one of these functions for iterations, then taking ensures that with probability at least no frequency will go below .
For bitvalues that have no uniform preference for a particular value (which is, naturally, the typical case for difficult optimization problems), we would still recommend to stick to the abovederived recommendations for setting since this at least avoids that frequencies reach the wrong value due to genetic drift. If a fitness landscape is badly deceptive, clearly, such arguments cannot avoid that frequencies approach the wrong end of the frequency range due to the misleading fitness signal. We note though that the heuristic argument for setting along the lines from above gives a good value and a good optimization behavior for the nonunimodal jump function class [HS18, Doe19c].
We finally note that there are three “automated” ways to approach the difficulty of finding the right parameter value. Inspired by the above insight, Doerr and Zheng [DZ20a] proposed to start with a small value of , run the cGA until either a satisfying solution is found or the time exceeds a limit up to which we are sure to not observe genetic drift and then restart with twice the value. In [Doe19c], a strategy is proposed that in parallel works with different values. Both approaches were proven to optimize simple test functions in a time that is by at most a logarithmic factor larger than the runtime that can be obtained from using the optimal value of . An experimental comparison [DZ20a] gives no clear picture which of the two approaches is superior. Clearly, both perform better than what results from a static, but inappropriate choice of .
Instead of solving the genetic drift problem via a suitable choice of , the significancebased cGA proposed in [DK20b] tries to avoid genetic drift outright. We recall that genetic drift is caused by random fluctuations of the frequencies, which again are caused by sampling search points from the probabilistic model and updating the model based on these. Therefore, the significancebased EDA avoids updating the model based on such shortsighted insights. Instead, this algorithm does not update the model until the history of the process gives sufficient evidence that some bit should better have a particular value. In this case, a drastic model update is performed by setting the corresponding frequency to or . This algorithm was shown to optimize both OneMax and LeadingOnes in time , a performance not observed with any other classic EA or EDA so far. With no research on nonunimodal objective functions and no practical experience so far, of course, this is still a very preliminary line of research.
7.3 Open Problems
Being a very recent research topic, it is clear that the theory of EDAs contains more open problems than solved ones, and many open problems are fundamental for our understanding and the future use of EDAs. We first mention briefly research topics where we feel that more results would greatly help and then give more details two particular research questions.

Robust optimization: The only two result [FKKS17, LN19b] here show that the cGA can efficiently optimize OneMax in the presence of normally distributed additive posterior noise and that the UMDA can efficiently optimize LeadingOnes in the presence of onebit prior noise. Having such results for other EDAs, other optimization problems, and other noise models (and other stochastic disturbances such as dynamically changing problem instances) would be highly desirable.

Combinatorial optimization: While for classic EAs a large number of runtime analyses for combinatorial optimization problems exist [NW10], no such results have been shown for EDAs.

Representations different from bit strings: For classic EAs, a number of results exist for problem representations different from bit strings, e.g., [STW04, DJ10, DDK18], and these results show that the choice of the representation and the choice of the variation operators for these can make a crucial difference. For EDAs, all results so far only discuss bitstring representations.
We now discuss in more detail two possible directions for future research.
7.3.1 Runtime Results in the Regime with Genetic Drift
In the regime without genetic drift, EDAs often show a regular optimization behavior which often allows to prove matching upper and lower bounds for runtimes. In the presence of genetic drift, the runtime is strongly influenced by how some frequencies approach the boundaries of the frequency range. It is thus rare events that determine the runtime and this makes it much harder to prove tight bounds. One could argue that runtime analyses in this regime are less interesting since we rather expect larger runtimes and rather an undesired behavior (e.g., imitating EAs), but this is not the full truth. For example, the UMDA optimizes OneMax in time both for in the regime with (strong) genetic drift and for in the regime without genetic drift.
Apart from sporadic results, which most likely are not tight in most of the cases, not much is known about the runtimes of EDAs in the genetic drift regime. In particular, the following questions are not understood.

Runtimes of EDAs for very high update strengths: The few runtime analyses in the genetic drift regime all assume that the update strength is at least so small that a (sufficiently large) logarithmic number of frequency updates is necessary to bring a frequency to a boundary value, e.g., that for some sufficiently large constant when considering the cGA. Nothing nontrivial is known for even larger update strengths, but it is conjectured that one will typically encounter a superpolynomial runtime here.

Runtimes of EDAs on OneMax for moderate update strengths. For the case that the update strength is smaller than in the previous paragraph, but still high enough to lead to genetic drift, a general lower bound for the cGA and UMDA [KW20b, SW19] and an upper bound for the UMDA [DLN19, Wit19] are known. For the cGA, a slightly stronger lower bound of was shown in the regime [LSW18]. With this being all that is known, a true understanding of this regime is far from established.

Runtimes of EDAs on jump functions: In the regime without genetic drift, a reasonable understanding of the runtime of the cGA on jump functions has been obtained in [HS18, Doe19c, Doe19b]. The lower bound [Doe19b], exponential in the jump size , also applies to the regime with genetic drift, but is by far not sufficient to explain the huge runtimes observed experimentally [DZ20a] in this regime. Hence a proof that the cGA optimizing jump functions suffers significantly from genetic drift is still missing.
7.3.2 Multivariate EDAs
Essentially all theoretical research so far regarded only univariate EDAs, that is, EDAs which evolve a univariate probabilistic model in which the bits are sampled independently. This is not surprising given how difficult it already was to obtain our limited understanding of univariate EDAs. Since more complex EDAs have the fantasy both of being better optimizers for complex optimization problems (in which often decision variables are highly interdependent) and of evolving better probabilistic models to represent the structure of interesting parts of the search space, a better understanding of multivariate EDAs is highly desirable.
So far, only two results in this direction exist, and both rely on theorydriven experiments and not on proven results. In [LN19a], the authors claim that the bivariate EDA mutual information maximization for input clustering (MIMIC) can cope better with fitness landscape in which the decision variables are interdependent. They define an artificial fitness landscape with strong intervariable dependencies, the DLBproblem, prove that the UMDA with needs time exponential in and show experimentally that the MIMIC can optimize this landscape in time polynomial in . Based on this finding, they suggest “that one should consider EDAs with more complex probabilistic models when optimizing problems with some degree of epistasis and deception.” As discussed in Section 7.2.3, the lower bound on the runtime of the UMDA only applies to the regime with strong genetic drift and from on, the runtime of the UMDA on DLB becomes [DK20c]. For this reason, it is not clear if the MIMIC, and more generally, bivariate EDAs, are also superior to the UMDA with the right choice of the parameters.
While hence no example exists in which a multivariate EDA shows a better optimization behavior than a univariate one (with good parameters), the recent work [DK20a] shows (again only experimentally) that bivariate EDAs can evolve very expressive probabilistic models. For a simple fitness landscape with global optima it is shown that the MIMIC very quickly evolves a probabilistic model which allows to sample global optima with constant chance and in a way that very rarely an optimum is sampled repeatedly. Hence the model evolved indeed represents to some extend the structure of the set of optimal solutions. It is clear that this would not be possible with a univariate EDA or a populationbased EA.
In summary, there is a cautious indication that multivariate EDAs could be interesting both from the viewpoint of good optimization times and good representations of the structure of the fitness landscape, but almost all of the work in this direction still needs to be done.
8 Final Words
We provided an overview on areas of research in the field of theory of evolutionary computation in discrete search spaces that have gained significant attention during the last 10 years. The survey tried to capture the most important aspects from the perspective of the authors. We refer to the recent edited book [DN20b]
for a more comprehensive overview, which also includes other evolutionary computing techniques such as genetic programming and artificial immune systems. For the true technical details, naturally, we invite the reader to consult the original articles.
There are many areas where we see a lot of room for progress. Analyses for constrained problems static, dynamic, or stochastic have just recently been started and understanding the behavior of evolutionary algorithms for linear functions even very special simple constraints is still a challenging task [NPW19]. A first analysis of differential evolution in discrete search spaces has been carried out in [ZYD18], however, indicating that our current methods cannot cope well with the complicated stochastic dependencies arising in this optimization process. The entropy compression method has found a first application in evolutionary computation [LMS19], but other applications of this powerful methods are not in sight. From a broader perspective, our understanding of the impact of populations, crossover operators, and diversity mechanisms still lags behind their practical success and proving the usefulness of such modules of an evolutionary algorithm for complex optimization problems is a challenging task.
We hope that the readers find this survey useful and that it helps them to understand the current theoretical research and to pursue their own research in this area. Although tremendous progress has been made during the last 10 years, there are still a lot of open questions and problems, some of which have been outlined in this article. We encourage the reader to make their own contribution to this field of research and help to transfer theoretical knowledge into the design of high performing evolutionary computing techniques.
References
 [AAG18] Youhei Akimoto, Anne Auger, and Tobias Glasmachers. Drift theory in continuous search spaces: expected hitting time of the (1 + 1)ES with 1/5 success rule. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 801–808. ACM, 2018.
 [ABD20a] Denis Antipov, Maxim Buzdalov, and Benjamin Doerr. Fast mutation in crossoverbased algorithms. In Genetic and Evolutionary Computation Conference, GECCO 2020. ACM, 2020. To appear.
 [ABD20b] Denis Antipov, Maxim Buzdalov, and Benjamin Doerr. First steps towards a runtime analysis when starting with a good solution. In Parallel Problem Solving From Nature, PPSN 2020. Springer, 2020. To appear.
 [AD20] Denis Antipov and Benjamin Doerr. Runtime analysis of a heavytailed genetic algorithm on jump functions. In Parallel Problem Solving From Nature, PPSN 2020. Springer, 2020. To appear.
 [ADFH18] Denis Antipov, Benjamin Doerr, Jiefeng Fang, and Tangi Hetet. Runtime analysis for the EA optimizing OneMax. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1459–1466. ACM, 2018.
 [ADY19] Denis Antipov, Benjamin Doerr, and Quentin Yang. The efficiency threshold for the offspring population size of the EA. In Genetic and Evolutionary Computation Conference, GECCO 2019, pages 1461–1469. ACM, 2019.
 [AHX20] Hirad Assimi, Oscar Harper, Yue Xie, Aneta Neumann, and Frank Neumann. Evolutionary biobjective optimization for the dynamic chanceconstrained knapsack problem based on tail bound objectives. CoRR, abs/2002.06766, 2020. Conference version to appear at ECAI 2020.
 [Bäc92] Thomas Bäck. Selfadaptation in genetic algorithms. In European Conference on Artifical Life, ECAL 1992, pages 263–271. MIT Press, 1992.
 [Bäc93] Thomas Bäck. Optimal mutation rates in genetic search. In International Conference on Genetic Algorithms, ICGA 1993, pages 2–8. Morgan Kaufmann, 1993.
 [Bäc96] Thomas Bäck. Evolutionary Algorithms in Theory and Practice – Evolution Strategies, Evolutionary Programming, Genetic Algorithms. Oxford University Press, 1996.
 [Bal94] Shumeet Baluja. Populationbased incremental learning: A method for integrating genetic search based function optimization and competitive learning. Technical report, Carnegie Mellon University, 1994.
 [BD17] Maxim Buzdalov and Benjamin Doerr. Runtime analysis of the genetic algorithm on random satisfiable 3CNF formulas. In Genetic and Evolutionary Computation Conference, GECCO 2017, pages 1343–1350. ACM, 2017.
 [BDM15] Weiwei Bi, Graeme C. Dandy, and Holger R. Maier. Improved genetic algorithm optimization of water distribution system design by incorporating domain knowledge. Environ. Model. Softw., 69:370–381, 2015.
 [BDN10] Süntje Böttcher, Benjamin Doerr, and Frank Neumann. Optimal fixed and adaptive mutation rates for the LeadingOnes problem. In Parallel Problem Solving from Nature, PPSN 2010, pages 1–10. Springer, 2010.
 [BFH09] Dimo Brockhoff, Tobias Friedrich, Nils Hebbinghaus, Christian Klein, Frank Neumann, and Eckart Zitzler. On the effects of adding objectives to plateau functions. IEEE Trans. Evol. Comput., 13(3):591–603, 2009.
 [BFM97] Thomas Bäck, David B. Fogel, and Zbigniew Michalewicz. Handbook of Evolutionary Computation. IOP Publishing Ltd., 1997.
 [BFQY20] Chao Bian, Chao Feng, Chao Qian, and Yang Yu. An efficient evolutionary algorithm for subset selection with general cost constraints. In AAAI, pages 3267–3274. AAAI Press, 2020.
 [BLM20] Daniel Bertschinger, Johannes Lengler, Anders Martinsson, Robert Meier, Angelika Steger, Miloš Trujić, and Emo Welzl. An optimal decentralized coloring algorithm. CoRR, abs/2002.05121, 2020.
 [BLS14] Golnaz Badkobeh, Per Kristian Lehre, and Dirk Sudholt. Unbiased blackbox complexity of parallel search. In Parallel Problem Solving from Nature, PPSN 2014, pages 892–901. Springer, 2014.
 [BM16] Mohammad Reza Bonyadi and Zbigniew Michalewicz. Evolutionary computation for realworld problems. In Challenges in Computational Statistics and Data Mining, volume 605 of Studies in Computational Intelligence, pages 1–24. Springer, 2016.
 [BNPS19] Jakob Bossek, Frank Neumann, Pan Peng, and Dirk Sudholt. Runtime analysis of randomized search heuristics for dynamic graph coloring. In GECCO, pages 1443–1451. ACM, 2019.
 [BNPS20] Jakob Bossek, Frank Neumann, Pan Peng, and Dirk Sudholt. More effective randomized search heuristics for graph coloring through dynamic optimization. CoRR, abs/2005.13825, 2020. To appear as full paper at GECCO 2020.
 [BQT18] Chao Bian, Chao Qian, and Ke Tang. Towards a running time analysis of the (1+1)EA for OneMax and LeadingOnes under general bitwise noise. In Parallel Problem Solving from Nature, PPSN 2018, Part II, pages 165–177. Springer, 2018.
 [CDEL18] Dogan Corus, DucCuong Dang, Anton V. Eremeev, and Per Kristian Lehre. Levelbased analysis of genetic algorithms and other search processes. IEEE Transactions on Evolutionary Computation, 22:707–719, 2018.
 [CHS09] Tianshi Chen, Jun He, Guangzhong Sun, Guoliang Chen, and Xin Yao. A new approach for analyzing average time complexity of populationbased evolutionary algorithms on unimodal problems. IEEE Transactions on Systems, Man, and Cybernetics, Part B, 39:1092–1106, 2009.
 [CLTY09] Tianshi Chen, Per Kristian Lehre, Ke Tang, and Xin Yao. When is an estimation of distribution algorithm better than an evolutionary algorithm? In Congress on Evolutionary Computation, CEC 2009, pages 1470–1477. IEEE, 2009.
 [CTCY10] Tianshi Chen, Ke Tang, Guoliang Chen, and Xin Yao. Analysis of computational time of simple estimation of distribution algorithms. IEEE Transactions on Evolutionary Computation, 14:1–22, 2010.
 [DD18] Benjamin Doerr and Carola Doerr. Optimal static and selfadjusting parameter choices for the genetic algorithm. Algorithmica, 80:1658–1709, 2018.
 [DDE15] Benjamin Doerr, Carola Doerr, and Franziska Ebel. From blackbox complexity to designing new genetic algorithms. Theoretical Computer Science, 567:87–104, 2015.
 [DDK18] Benjamin Doerr, Carola Doerr, and Timo Kötzing. Static and selfadjusting mutation strengths for multivalued decision variables. Algorithmica, 80:1732–1768, 2018.
 [DDL19] Benjamin Doerr, Carola Doerr, and Johannes Lengler. Selfadjusting mutation rates with provably optimal success rules. In Genetic and Evolutionary Computation Conference, GECCO 2019, pages 1479–1487. ACM, 2019.
 [DDN19] Benjamin Doerr, Carola Doerr, Aneta Neumann, Frank Neumann, and Andrew M. Sutton. Optimization of chanceconstrained submodular functions. CoRR, abs/1911.11451, 2019. to appear in proceedings of AAAI 2020.
 [DDY16] Benjamin Doerr, Carola Doerr, and Jing Yang. bit mutation with selfadjusting outperforms standard bit mutation. In Parallel Problem Solving from Nature, PPSN 2016, pages 824–834. Springer, 2016.
 [DDY20] Benjamin Doerr, Carola Doerr, and Jing Yang. Optimal parameter choices via precise blackbox analysis. Theoretical Computer Science, 801:1–34, 2020.
 [DF99] Rodney G. Downey and Michael R. Fellows. Parameterized Complexity. Springer, 1999.
 [DFW11] Benjamin Doerr, Mahmoud Fouz, and Carsten Witt. Sharp bounds by probabilitygenerating functions and variable drift. In Genetic and Evolutionary Computation Conference, GECCO 2011, pages 2083–2090. ACM, 2011.
 [DG13] Benjamin Doerr and Leslie A. Goldberg. Adaptive drift analysis. Algorithmica, 65:224–250, 2013.
 [DGWY19] Benjamin Doerr, Christian Gießen, Carsten Witt, and Jing Yang. The evolutionary algorithm with selfadjusting mutation rate. Algorithmica, 81:593–631, 2019.
 [DHK12] Benjamin Doerr, Ashish Ranjan Hota, and Timo Kötzing. Ants easily solve stochastic shortest path problems. In Genetic and Evolutionary Computation Conference, GECCO 2012, pages 17–24. ACM, 2012.
 [DHOW06] Vladimir G. Deineko, Michael Hoffmann, Yoshio Okamoto, and Gerhard J. Woeginger. The traveling salesman problem with few inner points. Oper. Res. Lett., 34(1):106–110, 2006.
 [DJ10] Benjamin Doerr and Daniel Johannsen. Edgebased representation beats vertexbased representation in shortest path problems. In Genetic and Evolutionary Computation Conference, GECCO 2010, pages 759–766. ACM, 2010.
 [DJS11] Benjamin Doerr, Daniel Johannsen, and M. Schmidt. Runtime analysis of the (1+1) evolutionary algorithm on strings over finite alphabets. In Foundations of Genetic Algorithms, FOGA 2011, pages 119–126. ACM, 2011.
 [DJS13] Benjamin Doerr, Thomas Jansen, Dirk Sudholt, Carola Winzen, and Christine Zarges. Mutation rate matters even when optimizing monotone functions. Evolutionary Computation, 21:1–21, 2013.
 [DJW00] Stefan Droste, Thomas Jansen, and Ingo Wegener. Dynamic parameter control in simple evolutionary algorithms. In Foundations of Genetic Algorithms, FOGA 2000, pages 275–294. Morgan Kaufmann, 2000.
 [DJW02] Stefan Droste, Thomas Jansen, and Ingo Wegener. On the analysis of the (1+1) evolutionary algorithm. Theoretical Computer Science, 276:51–81, 2002.
 [DJW12a] Benjamin Doerr, Daniel Johannsen, and Carola Winzen. Multiplicative drift analysis. Algorithmica, 64:673–697, 2012.
 [DJW12b] Benjamin Doerr, Daniel Johannsen, and Carola Winzen. Nonexistence of linear universal drift functions. Theoretical Computer Science, 436:71–86, 2012.
 [DK11] Abhimanyu Das and David Kempe. Submodular meets spectral: Greedy algorithms for subset selection, sparse approximation and dictionary selection. In ICML, pages 1057–1064. Omnipress, 2011.
 [DK15] Benjamin Doerr and Marvin Künnemann. Optimizing linear functions with the evolutionary algorithm—different asymptotic runtimes for different instances. Theoretical Computer Science, 561:3–23, 2015.
 [DK19] Benjamin Doerr and Timo Kötzing. Multiplicative updrift. In Genetic and Evolutionary Computation Conference, GECCO 2019, pages 1470–1478. ACM, 2019.
 [DK20a] Benjamin Doerr and Martin S. Krejca. Bivariate estimationofdistribution algorithms can find an exponential number of optima. In Genetic and Evolutionary Computation Conference, GECCO 2020. ACM, 2020. To appear.
 [DK20b] Benjamin Doerr and Martin S. Krejca. Significancebased estimationofdistribution algorithms. IEEE Transactions on Evolutionary Computation, 2020. To appear.
 [DK20c] Benjamin Doerr and Martin S. Krejca. The univariate marginal distribution algorithm copes well with deception and epistasis. In Evolutionary Computation in Combinatorial Optimization, EvoCOP 2020, pages 51–66. Springer, 2020.
 [DL15] DucCuong Dang and Per Kristian Lehre. Simplified runtime analysis of estimation of distribution algorithms. In Genetic and Evolutionary Computation Conference, GECCO 2015, pages 513–518. ACM, 2015.
 [DL16] DucCuong Dang and Per Kristian Lehre. Selfadaptation of mutation rates in nonelitist populations. In Parallel Problem Solving from Nature, PPSN 2016, pages 803–813. Springer, 2016.
 [DLMN17] Benjamin Doerr, Huu Phuoc Le, Régis Makhmara, and Ta Duy Nguyen. Fast genetic algorithms. In Genetic and Evolutionary Computation Conference, GECCO 2017, pages 777–784. ACM, 2017.
 [DLN19] DucCuong Dang, Per Kristian Lehre, and Phan Trung Hai Nguyen. Levelbased analysis of the univariate marginal distribution algorithm. Algorithmica, 81:668–702, 2019.
 [DLO19] Benjamin Doerr, Andrei Lissovoi, and Pietro Simone Oliveto. Evolving boolean functions with conjunctions and disjunctions via genetic programming. In Genetic and Evolutionary Computation Conference, GECCO 2019, pages 1003–1011. ACM, 2019.
 [DLOW18] Benjamin Doerr, Andrei Lissovoi, Pietro S. Oliveto, and John Alasdair Warwicker. On the runtime analysis of selection hyperheuristics with adaptive learning periods. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1015–1022. ACM, 2018.
 [DN20a] Viet Anh Do and Frank Neumann. Maximizing submodular or monotone functions under partition matroid constraints by multiobjective evolutionary algorithms. In PPSN, Lecture Notes in Computer Science. Springer, 2020. to appear.
 [DN20b] Benjamin Doerr and Frank Neumann, editors. Theory of Evolutionary Computation—Recent Developments in Discrete Optimization. Springer, 2020. Also available at https://cs.adelaide.edu.au/~frank/papers/TheoryBook2019selfarchived.pdf.
 [DNDD18] Raphaël DangNhu, Thibault Dardinier, Benjamin Doerr, Gautier Izacard, and Dorian Nogneng. A new analysis method for evolutionary optimization of dynamic and noisy objective functions. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1467–1474. ACM, 2018.
 [DNS17] Benjamin Doerr, Frank Neumann, and Andrew M. Sutton. Time complexity analysis of evolutionary algorithms on random satisfiable CNF formulas. Algorithmica, 78:561–586, 2017.
 [Doe11] Benjamin Doerr. Drift analysis. In Genetic and Evolutionary Computation Conference, GECCO 2011, Companion Material, pages 1311–1320. ACM, 2011.
 [Doe19a] Benjamin Doerr. Analyzing randomized search heuristics via stochastic domination. Theoretical Computer Science, 773:115–137, 2019.
 [Doe19b] Benjamin Doerr. An exponential lower bound for the runtime of the compact genetic algorithm on jump functions. In Foundations of Genetic Algorithms, FOGA 2019, pages 25–33. ACM, 2019.
 [Doe19c] Benjamin Doerr. A tight runtime analysis for the cGA on jump functions: EDAs can cross fitness valleys at no extra cost. In Genetic and Evolutionary Computation Conference, GECCO 2019, pages 1488–1496. ACM, 2019.
 [Doe20a] Benjamin Doerr. Does comma selection help to cope with local optima? In Genetic and Evolutionary Computation Conference, GECCO 2020. ACM, 2020. To appear.
 [Doe20b] Benjamin Doerr. Lower bounds for nonelitist evolutionary algorithms via negative multiplicative drift. In Parallel Problem Solving From Nature, PPSN 2020. Springer, 2020. To appear.
 [Dos13] Martin Dostál. Evolutionary music composition. In Handbook of Optimization, volume 38 of Intelligent Systems Reference Library, pages 935–964. Springer, 2013.
 [DP12] Benjamin Doerr and Sebastian Pohl. Runtime analysis of the (1+1) evolutionary algorithm optimizing linear functions over a finite alphabet. In Genetic and Evolutionary Computation Conference, GECCO 2012, pages 1317–1324. ACM, 2012.
 [Dro02] Stefan Droste. Analysis of the (1+1) EA for a dynamically changing OneMaxvariant. In Congress on Evolutionary Computation, CEC 2002, pages 55–60. IEEE, 2002.
 [Dro03] Stefan Droste. Analysis of the (1+1) EA for a dynamically bitwise changing onemax. In GECCO, volume 2723 of Lecture Notes in Computer Science, pages 909–921. Springer, 2003.
 [Dro04] Stefan Droste. Analysis of the (1+1) EA for a noisy onemax. In GECCO (1), volume 3102 of Lecture Notes in Computer Science, pages 1088–1099. Springer, 2004.
 [Dro06] Stefan Droste. A rigorous analysis of the compact genetic algorithm for linear functions. Natural Computing, 5:257–283, 2006.
 [DWY18a] Benjamin Doerr, Carsten Witt, and Jing Yang. Runtime analysis for selfadaptive mutation rates. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1475–1482. ACM, 2018.
 [DWY18b] Benjamin Doerr, Carsten Witt, and Jing Yang. Runtime analysis for selfadaptive mutation rates. CoRR, abs/1811.12824, 2018.
 [DZ20a] Benjamin Doerr and Weijie Zheng. A parameterless compact genetic algorithm. In Genetic and Evolutionary Computation Conference, GECCO 2020. ACM, 2020. To appear.
 [DZ20b] Benjamin Doerr and Weijie Zheng. Sharp bounds for genetic drift in estimationofdistribution algorithms. IEEE Transactions on Evolutionary Computation, 2020. To appear.
 [FGN19] Tobias Friedrich, Andreas Göbel, Frank Neumann, Francesco Quinzan, and Ralf Rothenberger. Greedy maximization of functions with bounded curvature under partition matroid constraints. In AAAI, pages 2272–2279. AAAI Press, 2019.
 [FGQW18a] Tobias Friedrich, Andreas Göbel, Francesco Quinzan, and Markus Wagner. Evolutionary algorithms and submodular functions: Benefits of heavytailed mutations. CoRR, abs/1805.10902, 2018.
 [FGQW18b] Tobias Friedrich, Andreas Göbel, Francesco Quinzan, and Markus Wagner. Heavytailed mutation operators in singleobjective combinatorial optimization. In Parallel Problem Solving from Nature, PPSN 2018, Part I, pages 134–145. Springer, 2018.
 [FHH10] Tobias Friedrich, Jun He, Nils Hebbinghaus, Frank Neumann, and Carsten Witt. Approximating covering problems by randomized search heuristics using multiobjective models. Evolutionary Computation, 18:617–633, 2010.
 [FK13] Matthias Feldmann and Timo Kötzing. Optimizing expected path lengths with ant colony optimization using fitness proportional update. In Foundations of Genetic Algorithms, FOGA 2013, pages 65–74. ACM, 2013.
 [FKK16] Tobias Friedrich, Timo Kötzing, and Martin S. Krejca. EDAs cannot be balanced and stable. In Genetic and Evolutionary Computation Conference, GECCO 2016, pages 1139–1146. ACM, 2016.
 [FKKS17] Tobias Friedrich, Timo Kötzing, Martin S. Krejca, and Andrew M. Sutton. The compact genetic algorithm is efficient under extreme Gaussian noise. IEEE Transactions on Evolutionary Computation, 21:477–490, 2017.
 [FKQS17] Tobias Friedrich, Timo Kötzing, Francesco Quinzan, and Andrew M. Sutton. Resampling vs recombination: a statistical run time estimation. In FOGA, pages 25–35. ACM, 2017.
 [FN14] Tobias Friedrich and Frank Neumann. Maximizing submodular functions under matroid constraints by multiobjective evolutionary algorithms. In 13th International Conference on Parallel Problem Solving from Nature (PPSN), volume 8672 of Lecture Notes in Computer Science, pages 922–931. Springer, 2014.
 [FQW18] Tobias Friedrich, Francesco Quinzan, and Markus Wagner. Escaping large deceptive basins of attraction with heavytailed mutation operators. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 293–300. ACM, 2018.
 [GK16] Christian Gießen and Timo Kötzing. Robustness of populations in stochastic environments. Algorithmica, 75(3):462–489, 2016.
 [GKK18] Andreas Göbel, Timo Kötzing, and Martin S. Krejca. Intuitive analyses via drift theory. CoRR, abs/1806.01919, 2018.
 [GKS99] Josselin Garnier, Leila Kallel, and Marc Schoenauer. Rigorous hitting times for binary mutations. Evolutionary Computation, 7:173–203, 1999.
 [GL10] Oliver Giel and Per Kristian Lehre. On the effect of populations in evolutionary multiobjective optimisation. Evol. Comput., 18(3):335–356, 2010.
 [GW17] Christian Gießen and Carsten Witt. The interplay of population size and mutation probability in the EA on OneMax. Algorithmica, 78:587–609, 2017.
 [GW18] Christian Gießen and Carsten Witt. Optimal mutation rates for the EA on OneMax through asymptotically tight drift analysis. Algorithmica, 80:1710–1731, 2018.
 [Haj82] Bruce Hajek. Hittingtime and occupationtime bounds implied by drift analysis with applications. Advances in Applied Probability, 13:502–525, 1982.
 [HLG99] Georges R. Harik, Fernando G. Lobo, and David E. Goldberg. The compact genetic algorithm. IEEE Transactions on Evolutionary Computation, 3:287–297, 1999.
 [HP11] Mark Hauschild and Martin Pelikan. An introduction and survey of estimation of distribution algorithms. Swarm and Evolutionary Compututation, 1:111–128, 2011.
 [HR97] Markus Hohfeld and G nter Rudolph. Towards a theory of populationbased incremental learning. In Conference on Evolutionary Computation, pages 1–5. IEEE Press, 1997.
 [HS18] Václav Hasenöhrl and Andrew M. Sutton. On the runtime dynamics of the compact genetic algorithm on jump functions. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 967–974. ACM, 2018.
 [HY01] Jun He and Xin Yao. Drift analysis and average time complexity of evolutionary algorithms. Artificial Intelligence, 127:51–81, 2001.

[Jäg08]
Jens Jägersküpper.
A blend of Markovchain and drift analysis.
In Parallel Problem Solving From Nature, PPSN 2008, pages 41–51. Springer, 2008.  [Jan07] Thomas Jansen. On the brittleness of evolutionary algorithms. In Foundations of Genetic Algorithms, FOGA 2007, pages 54–69. Springer, 2007.
 [JBS93] Ari Juels, Shumeet Baluja, and Alistair Sinclair. The equilibrium genetic algorithm and the role of crossover. Unpublished, 1993.
 [Jen04] Mikkel T. Jensen. Helperobjectives: Using multiobjective evolutionary algorithms for singleobjective optimisation. J. Math. Model. Algorithms, 3(4):323–347, 2004.
 [JJW05] Thomas Jansen, Kenneth A. De Jong, and Ingo Wegener. On the choice of the offspring population size in evolutionary algorithms. Evolutionary Computation, 13:413–440, 2005.
 [Joh10] Daniel Johannsen. Random Combinatorial Structures and Randomized Search Heuristics. PhD thesis, Universität des Saarlandes, 2010.
 [JOZ13] Thomas Jansen, Pietro Simone Oliveto, and Christine Zarges. Approximating vertex cover using edgebased representations. In FOGA, pages 87–96. ACM, 2013.
 [JS07] Jens Jägersküpper and Tobias Storch. When the plus strategy outperforms the comma strategy and when not. In Foundations of Computational Intelligence, FOCI 2007, pages 25–32. IEEE, 2007.
 [JW00] Thomas Jansen and Ingo Wegener. On the choice of the mutation probability for the (1+1) EA. In Parallel Problem Solving from Nature, PPSN 2000, pages 89–98. Springer, 2000.
 [JW06] Thomas Jansen and Ingo Wegener. On the analysis of a dynamic evolutionary algorithm. Journal of Discrete Algorithms, 4:181–199, 2006.
 [KG14] Andreas Krause and Daniel Golovin. Submodular function maximization. In Tractability, pages 71–104. Cambridge University Press, 2014.
 [KHE15] Giorgos Karafotias, Mark Hoogendoorn, and Ágoston E. Eiben. Parameter control in evolutionary algorithms: trends and challenges. IEEE Transactions on Evolutionary Computation, 19:167–187, 2015.
 [KLNO10] Stefan Kratsch, Per Kristian Lehre, Frank Neumann, and Pietro Simone Oliveto. Fixed parameter evolutionary algorithms and maximum leaf spanning trees: A matter of mutation. In PPSN (1), volume 6238 of Lecture Notes in Computer Science, pages 204–213. Springer, 2010.
 [KLW15a] Timo Kötzing, Andrei Lissovoi, and Carsten Witt. (1+1) EA on generalized dynamic OneMax. In Foundations of Genetic Algorithms, FOGA 2015, pages 40–51. ACM, 2015.
 [KLW15b] Timo Kötzing, Andrei Lissovoi, and Carsten Witt. (1+1) EA on generalized dynamic onemax. In FOGA, pages 40–51. ACM, 2015.
 [KM12] Timo Kötzing and Hendrik Molter. ACO beats EA on a dynamic pseudoboolean function. In PPSN (1), volume 7491 of Lecture Notes in Computer Science, pages 113–122. Springer, 2012.
 [KN13] Stefan Kratsch and Frank Neumann. Fixedparameter evolutionary algorithms and the vertex cover problem. Algorithmica, 65(4):754–771, 2013.
 [KU18] Adrian Kosowski and Przemyslaw Uznanski. Population protocols are fast. CoRR, abs/1802.06872, 2018.
 [KW20a] Martin Krejca and Carsten Witt. Theory of estimationofdistribution algorithms. In Benjamin Doerr and Frank Neumann, editors, Theory of Evolutionary Computation: Recent Developments in Discrete Optimization, pages 405–442. Springer, 2020. Also available at https://arxiv.org/abs/1806.05392.
 [KW20b] Martin S. Krejca and Carsten Witt. Lower bounds on the run time of the Univariate Marginal Distribution Algorithm on OneMax. Theoretical Computer Science, 2020. To appear.
 [Leh10] Per Kristian Lehre. Negative drift in populations. In Parallel Problem Solving from Nature, PPSN 2010, pages 244–253. Springer, 2010.
 [Leh11] Per Kristian Lehre. Fitnesslevels for nonelitist populations. In Genetic and Evolutionary Computation Conference, GECCO 2011, pages 2075–2082. ACM, 2011.
 [Len20] Johannes Lengler. Drift analysis. In Benjamin Doerr and Frank Neumann, editors, Theory of Evolutionary Computation: Recent Developments in Discrete Optimization, pages 89–131. Springer, 2020. Also available at https://arxiv.org/abs/1712.00964.
 [Lew08] Matthew R. Lewis. Evolutionary visual art and design. In The Art of Artificial Evolution, Natural Computing Series, pages 3–37. Springer, 2008.
 [LL02] Pedro Larrañaga and José Antonio Lozano, editors. Estimation of Distribution Algorithms. Genetic Algorithms and Evolutionary Computation. Springer, 2002.
 [LLM07] Fernando G. Lobo, Cláudio F. Lima, and Zbigniew Michalewicz, editors. Parameter Setting in Evolutionary Algorithms. Springer, 2007.
 [LMNS09] Jon Lee, Vahab S. Mirrokni, Viswanath Nagarajan, and Maxim Sviridenko. Nonmonotone submodular maximization under matroid and knapsack constraints. In STOC, pages 323–332. ACM, 2009.
 [LMS19] Johannes Lengler, Anders Martinsson, and Angelika Steger. When does hillclimbing fail on monotone functions: an entropy compression argument. In Analytic Algorithmics and Combinatorics, ANALCO 2019, pages 94–102. SIAM, 2019.
 [LN17] Per Kristian Lehre and Phan Trung Hai Nguyen. Improved runtime bounds for the univariate marginal distribution algorithm via anticoncentration. In Genetic and Evolutionary Computation Conference, GECCO 2017, pages 1383–1390. ACM, 2017.
 [LN19a] Per Kristian Lehre and Phan Trung Hai Nguyen. On the limitations of the univariate marginal distribution algorithm to deception and where bivariate EDAs might help. In Foundations of Genetic Algorithms, FOGA 2019, pages 154–168. ACM, 2019.
 [LN19b] Per Kristian Lehre and Phan Trung Hai Nguyen. Runtime analysis of the univariate marginal distribution algorithm under low selective pressure and prior noise. In Genetic and Evolutionary Computation Conference, GECCO 2019, pages 1497–1505. ACM, 2019.
 [Lob07] Fernando G. Lobo. Lost gems of EC: The equilibrium genetic algorithm and the role of crossover. SIGEVOlution, 2(2):14–15, 2007.
 [LS11] Jörg Lässig and Dirk Sudholt. Adaptive population models for offspring populations and parallel evolutionary algorithms. In Foundations of Genetic Algorithms, FOGA 2011, pages 181–192. ACM, 2011.
 [LS18] Johannes Lengler and Angelika Steger. Drift analysis and evolutionary algorithms revisited. Combinatorics, Probability & Computing, 27:643–666, 2018.
 [LSW18] Johannes Lengler, Dirk Sudholt, and Carsten Witt. Medium step sizes are harmful for the compact genetic algorithm. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1499–1506. ACM, 2018.
 [LW15] Andrei Lissovoi and Carsten Witt. Runtime analysis of ant colony optimization on dynamic shortest path problems. Theor. Comput. Sci., 561:73–85, 2015.
 [LW16] Andrei Lissovoi and Carsten Witt. MMAS versus populationbased EA on a family of dynamic fitness functions. Algorithmica, 75(3):554–576, 2016.
 [LW18] Andrei Lissovoi and Carsten Witt. The impact of a sparse migration topology on the runtime of island models in dynamic optimization. Algorithmica, 80(5):1634–1657, 2018.
 [MD10] Christie Myburgh and Kalyanmoy Deb. Evolutionary algorithms in largescale open pit mine scheduling. In GECCO, pages 1155–1162. ACM, 2010.
 [MP96] Heinz Mühlenbein and Gerhard Paass. From recombination of genes to the estimation of distributions I. Binary parameters. In Parallel Problem Solving from Nature, PPSN 1996, pages 178–187. Springer, 1996.
 [MRC09] Boris Mitavskiy, Jonathan E. Rowe, and Chris Cannings. Theoretical analysis of local search strategies to optimize network communication subject to preserving the total number of links. International Journal on Intelligent Computing and Cybernetics, 2:243–284, 2009.
 [MS15] Andrea Mambrini and Dirk Sudholt. Design and analysis of schemes for adapting migration intervals in parallel evolutionary algorithms. Evolutionary Computation, 23:559–582, 2015.
 [Müh92] Heinz Mühlenbein. How genetic algorithms really work: mutation and hillclimbing. In Parallel Problem Solving from Nature, PPSN 1992, pages 15–26. Elsevier, 1992.
 [NAN20] Aneta Neumann, Bradley Alexander, and Frank Neumann. Evolutionary image transition and painting using random walks. CoRR, abs/2003.01517, 2020. to appear in the journal Evolutionary Computation (MIT Press).
 [NAW20] Mehdi Neshat, Bradley Alexander, and Markus Wagner. A hybrid cooperative coevolution algorithm framework for optimising power take off and placements of wave energy converters. Inf. Sci., 534:218–244, 2020.
 [NN20] Aneta Neumann and Frank Neumann. Optimising chanceconstrained submodular functions using evolutionary multiobjective algorithms. In PPSN, Lecture Notes in Computer Science. Springer, 2020. to appear, available at http://arxiv.org/abs/2006.11444.
 [NOW09] Frank Neumann, Pietro S. Oliveto, and Carsten Witt. Theoretical analysis of fitnessproportional selection: landscapes and efficiency. In Genetic and Evolutionary Computation Conference, GECCO 2009, pages 835–842. ACM, 2009.
 [NPW19] Frank Neumann, Mojgan Pourhassan, and Carsten Witt. Improved runtime results for simple randomised search heuristics on linear functions with a uniform constraint. In GECCO, pages 1506–1514. ACM, 2019.
 [NS19] Frank Neumann and Andrew M. Sutton. Runtime analysis of the (1 + 1) evolutionary algorithm for the chanceconstrained knapsack problem. In FOGA, pages 147–153. ACM, 2019.
 [NSN13a] Samadhi Nallaperuma, Andrew M. Sutton, and Frank Neumann. Fixedparameter evolutionary algorithms for the euclidean traveling salesperson problem. In IEEE Congress on Evolutionary Computation, pages 2037–2044. IEEE, 2013.
 [NSN13b] Samadhi Nallaperuma, Andrew M. Sutton, and Frank Neumann. Parameterized complexity analysis and more effective construction methods for ACO algorithms and the euclidean traveling salesperson problem. In IEEE Congress on Evolutionary Computation, pages 2045–2052. IEEE, 2013.
 [NW06] Frank Neumann and Ingo Wegener. Minimum spanning trees made easier via multiobjective optimization. Nat. Comput., 5(3):305–319, 2006.
 [NW07] Frank Neumann and Ingo Wegener. Randomized local search, evolutionary algorithms, and the minimum spanning tree problem. Theoretical Computer Science, 378:32–40, 2007.
 [NW10] Frank Neumann and Carsten Witt. Bioinspired Computation in Combinatorial Optimization – Algorithms and Their Computational Complexity. Springer, 2010.
 [NW15] Frank Neumann and Carsten Witt. On the runtime of randomized local search and simple evolutionary algorithms for dynamic makespan scheduling. In IJCAI, pages 3742–3748. AAAI Press, 2015.
 [NWF78] George L. Nemhauser, Laurence A. Wolsey, and Marshall L. Fisher. An analysis of approximations for maximizing submodular set functions  I. Math. Program., 14(1):265–294, 1978.
 [Och02] Gabriela Ochoa. Setting the mutation rate: scope and limitations of the 1/L heuristic. In Genetic and Evolutionary Computation Conference, GECCO 2002, pages 495–502. Morgan Kaufmann, 2002.
 [OE12] Adrian Ogierman and Robert Elsässer. The impact of the power law exponent on the behavior of a dynamic epidemic type process. In Symposium on Parallelism in Algorithms and Architectures, SPAA 2012, pages 131–139. ACM, 2012.
 [OW11] Pietro S. Oliveto and Carsten Witt. Simplified drift analysis for proving lower bounds in evolutionary computation. Algorithmica, 59:369–386, 2011.
 [OW12] Pietro S. Oliveto and Carsten Witt. Erratum: Simplified drift analysis for proving lower bounds in evolutionary computation. CoRR, abs/1211.7184, 2012.
 [OW15] Pietro S. Oliveto and Carsten Witt. Improved time complexity analysis of the simple genetic algorithm. Theoretical Computer Science, 605:21–41, 2015.
 [OWBM13] Yuki Osada, R. Lyndon While, Luigi Barone, and Zbigniew Michalewicz. Multimine planning using a multiobjective evolutionary algorithm. In IEEE Congress on Evolutionary Computation, pages 2902–2909. IEEE, 2013.
 [PGN15] Mojgan Pourhassan, Wanru Gao, and Frank Neumann. Maintaining 2approximations for the dynamic vertex cover problem using evolutionary algorithms. In GECCO, pages 903–910. ACM, 2015.
 [PHL15] Martin Pelikan, Mark Hauschild, and Fernando G. Lobo. Estimation of distribution algorithms. In Janusz Kacprzyk and Witold Pedrycz, editors, Springer Handbook of Computational Intelligence, pages 899–928. Springer, 2015.
 [PRN20] Mojgan Pourhassan, Vahid Roostapour, and Frank Neumann. Runtime analysis of RLS and (1+1) EA for the dynamic weighted vertex cover problem. Theor. Comput. Sci., 832:20–41, 2020.
 [Prü04] Adam PrügelBennett. When a genetic algorithm outperforms hillclimbing. Theoretical Computer Science, 320:135–153, 2004.
 [PSN19] Mojgan Pourhassan, Feng Shi, and Frank Neumann. Parameterized analysis of multiobjective evolutionary algorithms and the weighted vertex cover problem. Evol. Comput., 27(4):559–575, 2019.
 [QBJT19] Chao Qian, Chao Bian, Wu Jiang, and Ke Tang. Running time analysis of the EA for OneMax and LeadingOnes under bitwise noise. Algorithmica, 81:749–795, 2019.
 [QSYT17] Chao Qian, JingCheng Shi, Yang Yu, and Ke Tang. On subset selection with general cost constraints. In Carles Sierra, editor, Proceedings of the TwentySixth International Joint Conference on Artificial Intelligence, IJCAI 2017, Melbourne, Australia, August 1925, 2017, pages 2613–2619. ijcai.org, 2017.
 [QYT19] Chao Qian, Yang Yu, Ke Tang, Xin Yao, and ZhiHua Zhou. Maximizing submodular or monotone approximately submodular functions by multiobjective evolutionary algorithms. Artif. Intell., 275:279–294, 2019.
 [QYZ15] Chao Qian, Yang Yu, and ZhiHua Zhou. Subset selection by pareto optimization. In NIPS, pages 1774–1782, 2015.
 [Rec73] Ingo Rechenberg. Evolutionsstrategie. Friedrich Fromman Verlag (Günther Holzboog KG), Stuttgart, 1973.
 [RNN20] Vahid Roostapour, Aneta Neumann, and Frank Neumann. Evolutionary multiobjective optimization for the dynamic knapsack problem. CoRR, abs/2004.12574, 2020. Conference version appeared at PPSN 2018.
 [RNNF18] Vahid Roostapour, Aneta Neumann, Frank Neumann, and Tobias Friedrich. Pareto optimization for subset selection with dynamic cost constraints. CoRR, abs/1811.07806, 2018.
 [RNNF19] Vahid Roostapour, Aneta Neumann, Frank Neumann, and Tobias Friedrich. Pareto optimization for subset selection with dynamic cost constraints. In AAAI, pages 2354–2361. AAAI Press, 2019.
 [Row18] Jonathan E. Rowe. Linear multiobjective drift analysis. Theoretical Computer Science, 736:25–40, 2018.
 [RPN18] Vahid Roostapour, Mojgan Pourhassan, and Frank Neumann. Analysis of evolutionary algorithms in dynamic and stochastic environments. CoRR, abs/1806.08547, 2018.
 [RS14] Jonathan E. Rowe and Dirk Sudholt. The choice of the offspring population size in the (1, ) evolutionary algorithm. Theoretical Computer Science, 545:20–38, 2014.
 [Rud97] Günter Rudolph. Convergence properties of evolutionary algorithms. Kovac, 1997.
 [RW20] Amirhossein Rajabi and Carsten Witt. Selfadjusting evolutionary algorithms for multimodal optimization. In Genetic and Evolutionary Computation Conference, GECCO 2020. ACM, 2020. To appear.
 [Sha02] Jonathan L. Shapiro. The sensitivity of PBIL to its learning rate, and how detailed balance can remove it. In Foundations of Genetic Algorithms, FOGA 2002, pages 115–132. Morgan Kaufmann, 2002.
 [Sha05] Jonathan L. Shapiro. Drift and scaling in estimation of distribution algorithms. Evolutionary Computing, 13:99–123, 2005.
 [Sha06] Jonathan L. Shapiro. Diversity loss in general estimation of distribution algorithms. In Parallel Problem Solving from Nature, PPSN 2006, pages 92–101. Springer, 2006.
 [SN12] Andrew M. Sutton and Frank Neumann. A parameterized runtime analysis of evolutionary algorithms for the Euclidean traveling salesperson problem. In Proceedings of the TwentySixth Conference on Artificial Intelligence (AAAI’12), pages 1105–1111. AAAI Press, 2012.
 [SNN14] Andrew M. Sutton, Frank Neumann, and Samadhi Nallaperuma. Parameterized runtime analyses of evolutionary algorithms for the planar euclidean traveling salesperson problem. Evol. Comput., 22(4):595–628, 2014.
 [SSF19] Feng Shi, Martin Schirneck, Tobias Friedrich, Timo Kötzing, and Frank Neumann. Reoptimization time analysis of evolutionary algorithms on linear functions under dynamic uniform constraints. Algorithmica, 81(2):828–857, 2019.
 [ST12] Dirk Sudholt and Christian Thyssen. A simple ant colony optimizer for stochastic shortest path problems. Algorithmica, 64:643–672, 2012.
 [Sto06] Tobias Storch. How randomized search heuristics find maximum cliques in planar graphs. In GECCO, pages 567–574. ACM, 2006.
 [Sto07] Tobias Storch. Finding large cliques in sparse semirandom graphs by simple randomized search heuristics. Theor. Comput. Sci., 386(12):114–131, 2007.
 [STW04] Jens Scharnow, Karsten Tinnefeld, and Ingo Wegener. The analysis of evolutionary algorithms on sorting and shortest paths problems. Journal of Mathematical Modelling and Algorithms, 3:349–366, 2004.
 [Sud13] Dirk Sudholt. A new method for lower bounds on the running time of evolutionary algorithms. IEEE Transactions on Evolutionary Computation, 17:418–435, 2013.
 [Sud18] Dirk Sudholt. On the robustness of evolutionary algorithms to noise: refined results and an example where noise helps. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1523–1530. ACM, 2018.
 [SW19] Dirk Sudholt and Carsten Witt. On the choice of the update strength in estimationofdistribution algorithms and ant colony optimization. Algorithmica, 81:1450–1489, 2019.
 [The09] Madeleine Theile. Exact solutions to the traveling salesperson problem by a populationbased evolutionary algorithm. In Evolutionary Computation in Combinatorial Optimization, EvoCOP 2009, pages 145–155. Springer, 2009.
 [TWD13] Raymond Tran, Junhua Wu, Christopher Denison, Thomas Ackling, Markus Wagner, and Frank Neumann. Fast and effective multiobjective optimisation of wind turbine placement. In GECCO, pages 1381–1388. ACM, 2013.
 [Weg01] Ingo Wegener. Theoretical aspects of evolutionary algorithms. In Automata, Languages and Programming, ICALP 2001, pages 64–78. Springer, 2001.
 [Wit06] Carsten Witt. Runtime analysis of the ( + 1) EA on simple pseudoBoolean functions. Evolutionary Computation, 14:65–86, 2006.
 [Wit13] Carsten Witt. Tight bounds on the optimization time of a randomized search heuristic on linear functions. Combinatorics, Probability & Computing, 22:294–318, 2013.
 [Wit19] Carsten Witt. Upper bounds on the running time of the univariate marginal distribution algorithm on OneMax. Algorithmica, 81:632–667, 2019.
 [WQT18] Mengxi Wu, Chao Qian, and Ke Tang. Dynamic mutation based Pareto optimization for subset selection. In Intelligent Computing Methodologies, ICIC 2018, Part III, pages 25–35. Springer, 2018.
 [XHA19] Yue Xie, Oscar Harper, Hirad Assimi, Aneta Neumann, and Frank Neumann. Evolutionary algorithms for the chanceconstrained knapsack problem. In GECCO, pages 338–346. ACM, 2019.
 [XNN20] Yue Xie, Aneta Neumann, and Frank Neumann. Specific single and multiobjective evolutionary algorithms for the chanceconstrained knapsack problem. CoRR, abs/2004.03205, 2020. Conference version to appear at GECCO 2020.
 [ZYD18] Weijie Zheng, Guangwen Yang, and Benjamin Doerr. Working principles of binary differential evolution. In Genetic and Evolutionary Computation Conference, GECCO 2018, pages 1103–1110. ACM, 2018.
 [ZYQ19] ZhiHua Zhou, Yang Yu, and Chao Qian. Evolutionary Learning: Advances in Theories and Algorithms. Springer, 2019.