Elsevier

Theoretical Computer Science

Volume 832, 6 September 2020, Pages 143-165
Theoretical Computer Science

Lower bounds on the run time of the Univariate Marginal Distribution Algorithm on OneMax

https://doi.org/10.1016/j.tcs.2018.06.004Get rights and content

Abstract

The Univariate Marginal Distribution Algorithm (UMDA) – a popular estimation-of-distribution algorithm – is studied from a run time perspective. On the classical OneMax benchmark function on bit strings of length n, a lower bound of Ω(λ+μn+nlogn), where μ and λ are algorithm-specific parameters, on its expected run time is proved. This is the first direct lower bound on the run time of UMDA. It is stronger than the bounds that follow from general black-box complexity theory and is matched by the run time of many evolutionary algorithms. The results are obtained through advanced analyses of the stochastic change of the frequencies of bit values maintained by the algorithm, including carefully designed potential functions. These techniques may prove useful in advancing the field of run time analysis for estimation-of-distribution algorithms in general.

Introduction

Traditional algorithms in the field of Evolutionary Computation optimize problems by sampling a certain amount of solutions from the problem domain, the so-called population, and transforming them, such that the new population is closer to an optimum. Estimation-of-distribution algorithms (EDAs; [1]) have a very similar approach but do not store an explicit population of sample solutions. Instead, they store a probability distribution over the problem domain and update it via an algorithm-specific rule that learns from samples drawn from said distribution.

Although many different variants of EDAs (cf. [2]) and many different domains are possible, theoretical analyses of EDAs in discrete search spaces often consider run times over {0,1}n. Further, the focus is on EDAs that store a Poisson binomial distribution, i.e., EDAs that store a probability vector p of n independent probabilities, each component pi denoting the probability that a sampled bit string will have a 1 at position i.

The first theoretical analysis in this setting was conducted by Droste [3], who analyzed the compact Genetic Algorithm (cGA) – an EDA that only samples two solutions each iteration – on linear functions. Papers considering other EDAs, like, e.g., an iteration-best Ant Colony Optimization (ACO) algorithm by Neumann et al. [4] followed, where the pheromone vector represents the probability vector of an EDA.

Recently, the interest in the theoretical analysis of EDAs has increased [5], [6], [7], [8], [9], [10]. Most of these works derive upper bounds for a specific EDA on the popular OneMax function, which counts the number of 1s in a bit string and is considered to be one of the easiest functions with a unique optimum for most EAs [11], [12]. The only exceptions are Friedrich et al. [6], who look at general properties of EDAs, Sudholt and Witt [9], who derive lower bounds on OneMax for the aforementioned cGA and an iteration-best ACO, and Dang and Lehre [5], who focus on general methods for upper bounds.

In this paper, we follow the ideas of Sudholt and Witt [9] and derive a lower bound of Ω(nlogn) for the Univariate Marginal Distribution Algorithm (UMDA; [13]) on OneMax, which is a typical lower bound for many evolutionary algorithms on this function. UMDA is an EDA that samples λ solutions each iteration, selects μ<λ best solutions, and then sets pi to the relative occurrence of 1s among these μ individuals. The algorithm has already been analyzed some years ago for several artificially designed example functions [14], [15], [16], [17]. However, none of these papers consider the standard benchmark function for theory: the OneMax function. In fact, the run time analysis of UMDA on the simple OneMax function has turned out to be rather challenging; the first such result, showing an upper bound of O(nlognloglogn) on its expected run time for certain settings of μ and λ, was not published until 2015 [5]. Specific lower bounds for UMDA were to date missing; the previous best result Ω(n/logn) on the expected run time followed from general black box complexity theory [18] and did not shed light on the working principles of UMDA.

Recently, two matching upper bounds of O(nlogn) of UMDA on OneMax have been proved independently from one another [8], [10] for certain cases of μ and λ. Our results match almost all of these cases, providing a tight run time bound of Θ(nlogn).

The concepts of the proofs in this paper are based on the prior work from Sudholt and Witt [9]. However, analyzing UMDA is much more difficult than analyzing cGA or iteration-best ACO, since the update of the latter algorithms is bounded by an algorithm-specific parameter and the algorithms only have up to three distinct successor states for each value pi. UMDA, on the other hand, can change each of its pi to any value x/μ with a certain probability, where x{0,,μ}, due to the nature of its update rule. This makes analyzing UMDA far more involved, because every single update has to be bounded probabilistically. Further, the simple update rules for cGA and iteration-best ACO allow for a distinction into two cases that determines whether a value pi will increase or decrease; a fact that was heavily exploited in the analyses in [9]. For UMDA, no such simple case distinction can be made.

This paper is structured as follows: in Section 2, we shortly introduce the setting we are going to analyze and go into detail about UMDA's update rule, that is, we explain and analyze a property of the algorithm that leads to the lower bound when optimizing OneMax.

Then in Section 3, we state our main result – a run time bound of Ω(nlogn) (Theorem 6) – and prove it step by step. The rough outline of the proof follows the one presented in [9]. However, we think that our style of presentation is more accessible, due to dissecting our proof into smaller (and often independent) lemmas.

In Section 4, we relax the condition of Theorem 6 with respect to the dependency of μ to λ and also prove a bound of Ω(nlogn) (Theorem 20). Our result holds for values of μclogn, for a sufficiently small constant c. This includes the case μ=1, for which no matching upper bound has explicitly been proved up to date.1

Finally, we conclude and discuss our results and future work in the Conclusions section.

We think that parts of our results (especially the detailed analysis of the selection process in Section 2.2) can also be used when analyzing UMDA on other functions than OneMax.

This version is an extension of our prior lower-bound analysis of UMDA [20] in the way that we also consider the case of μclogn (for a sufficiently small constant c), independent of λ>μ.

Section snippets

Preliminaries

We consider the Univariate Marginal Distribution Algorithm (UMDA [13]; Algorithm 1) maximizing the pseudo-Boolean function OneMax, where, for all x{0,1}n,OneMax(x)=i=1nxi. Note that the function's unique maximum is the all-ones bit string. However, a more general version can be defined by choosing an arbitrary optimum a{0,1}n and defining, for all x{0,1}n,OneMaxa(x)=ndH(x,a), where dH(x,a) denotes the Hamming distance of the bit strings x and a. Note that OneMax1n is equivalent to the

Lower bound on OneMax

In the following, we derive a lower bound on UMDA's run time on OneMax. First, we state the main theorem.

Theorem 6

Let λ=(1+β)μ for some constant β>0. Then the expected optimization time of UMDA on OneMax is Ω(μn+nlogn).

To prove the theorem, we will distinguish between different cases for λ: small, medium, and large. We will cover the lemmas we use to prove the different cases in different sections. The first and the last case are fairly easy to prove, hence we discuss them first, leaving the second

Relaxing the condition on the population size

Theorem 6, which most of the paper was concerned with, assumed that λ=(1+β)μ for some constant β>0. We think that the lower bound of Ω(nlogn) holds for all combinations of μ and λ. As a step toward a proof of this conjecture, we extend our lower bound toward all μclogn for a sufficiently small constant c>0. This includes the extreme case of μ=1, for which no matching upper bound has been proved up to date.

Theorem 20

Let μclogn for a sufficiently small constant c>0, and let λ=nO(1). Then the

Conclusions

We have analyzed UMDA on OneMax and obtained the general bound Ω(λ+μn+nlogn) on its expected run time for combinations of μ and λ where λ=O(μ) or μclogn (for a sufficiently small constant c). This lower bound analysis is the first of its kind and contributes advanced techniques, including potential functions.

We note that our lower bound for UMDA is tight in many cases, as has been shown recently [8], [10]. We also note that our main result assumes λ=O(μ). However, we do not think that larger

Acknowledgments

Financial support by the Danish Council for Independent Research (DFF-FNU 4002-00542) is gratefully acknowledged.

The authors would like to thank the anonymous reviewers of the conference and journal version for their comments, which greatly improved the quality of this paper.

References (24)

  • M. Hauschild et al.

    An introduction and survey of estimation of distribution algorithms

    Swarm Evol. Comput.

    (2011)
  • P.S. Oliveto et al.

    Improved time complexity analysis of the simple genetic algorithm

    Theoret. Comput. Sci.

    (2015)
  • S. Droste

    A rigorous analysis of the compact genetic algorithm for linear functions

    Nat. Comput.

    (2006)
  • F. Neumann et al.

    A few ants are enough: ACO with iteration-best update

  • D. Dang et al.

    Simplified runtime analysis of estimation of distribution algorithms

  • T. Friedrich et al.

    EDAs cannot be balanced and stable

  • T. Friedrich et al.

    The benefit of recombination in noisy evolutionary search

  • P.K. Lehre et al.

    Improved runtime bounds for the univariate marginal distribution algorithm via anti-concentration

  • D. Sudholt et al.

    Update strength in EDAs and ACO: how to avoid genetic drift

  • C. Witt

    Upper bounds on the runtime of the univariate marginal distribution algorithm on OneMax

  • D. Sudholt

    A new method for lower bounds on the running time of evolutionary algorithms

    IEEE Trans. Evol. Comput.

    (2013)
  • Cited by (0)

    View full text