Runtime Analysis for Permutation-based Evolutionary Algorithms

TL;DR

This work addresses the gap in theoretical understanding of permutation-based evolutionary algorithms by proposing a general method to translate bit-string benchmarks into permutation benchmarks and analyzing the permutation-based $(1+1)$ EA with swap mutations. It delivers tight runtime results for permutation-Leading-Ones, $oldsymbol{ heta(n^3)}$, and for permutation-Jump under swap mutations, $oldsymbol{O(n^{2\lceil m/2\rceil})}$, while showing that scramble mutations yield $oldsymbol{ heta(n^m)}$ runtimes on Jump and make results parity-independent; heavy-tailed mutations further speed up Jump by $oldsymbol{m^{\Theta(m)}}$. The empirical study corroborates the theory and highlights the importance of mutation-rate details, such as void mutations, in finite-size problems. Overall, the paper demonstrates that the richer combinatorial structure of permutation spaces both complicates analyses and offers new, effective mutation strategies, guiding future research on precise runtime results and broader benchmarks in permutation-based EAs.

Abstract

While the theoretical analysis of evolutionary algorithms (EAs) has made significant progress for pseudo-Boolean optimization problems in the last 25 years, only sporadic theoretical results exist on how EAs solve permutation-based problems. To overcome the lack of permutation-based benchmark problems, we propose a general way to transfer the classic pseudo-Boolean benchmarks into benchmarks defined on sets of permutations. We then conduct a rigorous runtime analysis of the permutation-based $(1+1)$ EA proposed by Scharnow, Tinnefeld, and Wegener (2004) on the analogues of the LeadingOnes and Jump benchmarks. The latter shows that, different from bit-strings, it is not only the Hamming distance that determines how difficult it is to mutate a permutation $σ$ into another one $τ$, but also the precise cycle structure of $στ^{-1}$. For this reason, we also regard the more symmetric scramble mutation operator. We observe that it not only leads to simpler proofs, but also reduces the runtime on jump functions with odd jump size by a factor of $Θ(n)$. Finally, we show that a heavy-tailed version of the scramble operator, as in the bit-string case, leads to a speed-up of order $m^{Θ(m)}$ on jump functions with jump size $m$. A short empirical analysis confirms these findings, but also reveals that small implementation details like the rate of void mutations can make an important difference.

Figures (2)

• Figure 1: Runtimes of the $(1 + 1)$ EA with different mutation operators on the permutation-based Leading-Ones problem for problems sizes $n = 20, 30, \dots, 200$. The starred versions (dotted lines) are those that do not count easy-to-detect mutations in which parent and offspring are identical. Since the heavy-tailed swap operator does not have such mutations, these two lines are identical and cannot be seen separately in the figure.
• Figure 2: Runtimes of the $(1 + 1)$ EA with different mutation operators on the permutation-based Jump problem of fixed problem size $n=20$ with jump sizes $m \in [3..7]$ (no data point for the Poisson scramble operator for $m=7$ due to the excessive runtimes). The starred versions (dotted lines) are those that do not count easy-to-detect mutations in which parent and offspring are identical. Since the heavy-tailed swap operator does not have such mutations, these two lines are identical and cannot be seen separately in the figure.

Theorems & Definitions (33)

• Lemma 1: Remond13
• Lemma 2
• proof
• Theorem 3
• proof
• Theorem 4
• Lemma 5
• proof : Proof
• Lemma 6
• proof