Fragile Complexity of Comparison-Based Algorithms

TL;DR

This paper introduces the concept of fragile complexity in comparison-based algorithms, analyzing the maximum comparisons any element undergoes, and provides bounds and separations between deterministic and randomized approaches for fundamental problems.

Contribution

It defines fragile complexity, establishes bounds for core problems, and demonstrates differences between deterministic and randomized algorithms in this context.

Findings

Fragile complexity differs from comparator network depth.

Randomization can reduce fragile complexity.

Bounds are established for Minimum, Selection, Sorting, and Heap Construction.

Abstract

We initiate a study of algorithms with a focus on the computational complexity of individual elements, and introduce the fragile complexity of comparison-based algorithms as the maximal number of comparisons any individual element takes part in. We give a number of upper and lower bounds on the fragile complexity for fundamental problems, including Minimum, Selection, Sorting and Heap Construction. The results include both deterministic and randomized upper and lower bounds, and demonstrate a separation between the two settings for a number of problems. The depth of a comparator network is a straight-forward upper bound on the worst case fragile complexity of the corresponding fragile algorithm. We prove that fragile complexity is a different and strictly easier property than the depth of comparator networks, in the sense that for some problems a fragile complexity equal to the best network depth can be achieved with less total work and that with randomization, even a lower fragile complexity is possible.

Tables

Table 1. Table 1 : Summary of presented results. Notation: f ​ ( n ) 𝑓 𝑛 f(n) means fragile complexity; w ​ ( n ) 𝑤 𝑛 w(n) means work; ⟨ f m ​ ( n ) , f r ​ e ​ m ​ ( n ) ⟩ subscript 𝑓 𝑚 𝑛 subscript 𝑓 𝑟 𝑒 𝑚 𝑛 \langle f_{m}(n),f_{rem}(n)\rangle means fragile complexity for the selected element (minimum/median) and for the remaining elements, respectively – except for lower bounds, where it means ⟨ ⟨ \langle expected for the selected, limit for remaining ⟩ ⟩ \rangle ; † † \dagger means holds in expectation; ‡ ‡ \ddagger means holds with high probability ( 1 − 1 / n 1 1 𝑛 1-1/n ). ε > 0 𝜀 0 \varepsilon>0 is an arbitrary constant.

Problem		Upper		Lower
		$f\left(n\right)$	$w\left(n\right)$	$f\left(n\right)$
Minimum	Determ.	$𝒪\left(\log n\right)$  [T 3.1]	$𝒪\left(n\right)$	$f_{\text{min}}=\Omega \left(\log n\right)$ [T 3.1]
	(Sec. 3)
	Rand.	$⟨𝒪{\left({\log }_{\Delta }n\right)}^{†},𝒪{\left(\Delta +{\log }_{\Delta }n\right)}^{†}⟩$ [T 3.15]		$⟨\Omega {\left({\log }_{\Delta }n\right)}^{†},\Delta ⟩$ [T 3.17]
	(Sec. 3)	$⟨𝒪{\left(1\right)}^{†},𝒪\left(n^{\epsilon }\right)⟩$ (setting $\Delta =n^{\epsilon }$)	$𝒪\left(n\right)$
		$O{\left(\frac{\log n}{\log \log n}\right)}^{†}$ [Cor 3.18]		$\Omega {\left(\frac{\log n}{\log \log n}\right)}^{†}$ [Cor 3.18]
		$⟨O{\left({\log }_{\Delta }n\log \log \Delta \right)}^{‡},$	$𝒪\left(n\right)$	$f_{\text{min}}=$
		$O{(\Delta +{\log }_{\Delta }n\log \log \Delta )}^{‡}⟩$ [T 3.15]	$𝒪\left(n\right)$	$=\Omega {\left(\log \log n\right)}^{‡}$ [T 3.25]
Selection	Determ.	$𝒪\left(\log n\right)$ [T 4.1]	$𝒪\left(n\right)$ [T 4.1]	$\Omega \left(\log n\right)$ [Cor 3.3]
	(Sec. 4)
	Rand.	$⟨𝒪{\left(\log \log n\right)}^{†},𝒪{\left(\sqrt{n}\right)}^{†}⟩$ [T 4.12]	$𝒪{\left(n\right)}^{†}$	$⟨\Omega {\left({\log }_{\Delta }n\right)}^{†},\Delta ⟩$ [T 3.17]
	(Sec. 4)	$⟨𝒪{\left(\frac{\log n}{\log \log n}\right)}^{†},𝒪{\left({\log }^{2}n\right)}^{†}⟩$ [T 4.12]
Merge	Determ.	$𝒪\left(\log n\right)$ [T 5.13]	$𝒪\left(n\right)$	$\Omega \left(\log n\right)$ [Lem 5.1]
	(Sec. 5)
Heap	Determ.	$𝒪\left(\log n\right)$ [Obs 6.1]	$𝒪\left(n\right)$	$\Omega \left(\log n\right)$ [T 3.1]
Constr.	(Sec. 6)

Equations

$$T(n)\leq\left\{\begin{array}[]{ll}\max\left\{3+T(n/2),2+\log n\right\}&\mbox{ if }n>8\\ 3&\mbox{ if }n\leq 8\end{array}\right.,$$

$$\mathbf{Pr}[|C|=k\mid y\notin A]=\frac{k\cdot \left(\genfrac{}{}{0ex}{}{n-(k+2)}{\lceil n/2\rceil -2}\right)}{\left(\genfrac{}{}{0ex}{}{n-1}{\lceil n/2\rceil }\right)}=k\cdot \frac{(n-(k+2))!}{(\lfloor n/2\rfloor -k)!(\lceil n/2\rceil -2)!}\cdot \frac{(\lceil n/2\rceil )!(\lfloor n/2\rfloor -1)!}{(n-1)!}$$

$$\mathbf{Pr}[|C|=k\mid y\notin A]$$

$$k=1:\text{mbox}$$

$$\le \frac{1}{(n-1)(n-2)}\cdot \frac{(n+1)}{2}\cdot \frac{(n-1)}{2}$$

$$=\frac{n+1}{4\cdot (n-2)}\le \frac{1}{2}=\frac{k}{2^k}\text{mbox}foreveryn\ge 5.$$

$$k\ge 2:\text{mbox}$$

$$\le k\cdot \frac{1}{{\prod }_{i=1}^{k+1}(n-i)}\cdot \frac{n+1}{2}\cdot \frac{n-1}{2}\cdot \prod _{i=1}^{k-1}\frac{n-2i}{2}$$

$$\le \frac{k}{2^{k+1}}\cdot (n+1)(n-1)\cdot \frac{{\prod }_{i=1}^{k-1}(n-2i)}{{\prod }_{i=1}^{k+1}(n-i)}$$

$$\le \frac{k}{2^{k+1}}\cdot (n+1)(n-1)\cdot \frac{n-2}{(n-1)(n-2)(n-3)}$$

$$=\frac{k}{2^{k+1}}\cdot \frac{n+1}{n-3}\le \frac{k}{2^{k+1}}\cdot 2=\frac{k}{2^k}\text{mbox}foreveryn\ge 7.$$

$$p_i\le {\left(1-\frac{b-1}{a}\right)}^{t-1}\le {\left(1-\frac{b-1}{a}\right)}^{\gamma n^{1/3}-1}=\exp \left(-\Theta \left(\frac{b\gamma n^{1/3}}{a}\right)\right).$$

$$\mathbf{Pr}[|D|\ge \gamma |X{|}^{1/3}]<n\cdot \exp \left(-\Theta \left(\frac{\gamma n^{1/3}{n}^{2/3}}{n/2}\right)\right)=n\cdot \exp \left(-\Theta (\gamma )\right).$$

$$\mathbf{Pr}[|D^{(i)}|\ge \gamma |X^{(i)}{|}^{1/3}]<|X^{(i)}|\exp \left(-\Theta \left(|X^{(i)}{|}^{1/3}\right)\right)<\exp \left(-\Theta \left(|X^{(i)}{|}^{1/3}\right)\right)$$

$$\displaystyle\mathbf{Pr}\Big{[}\vphantom{\frac{1}{2}}\mathbf{f}_{1}\geq c^{\prime}(f_{1}+\log\log\Delta)\vee\dots\vee\mathbf{f}_{h}\geq c^{\prime}(f_{h}+\log\log\Delta)\Big{]}\leq\Delta^{h}e^{-\sum_{i}2^{f_{i}}}\leq\Delta^{h}e^{-h2^{k/h}}$$

$$\begin{gathered} \mathbf{Pr}[f_{\text{min}}=O(k+h\log \log \Delta )]\le \left(\genfrac{}{}{0ex}{}{h+k}{h}\right)\cdot {\Delta }^h\frac{1}{e^{h\cdot 2^{k/h}}}\le {\left(\frac{e(h+k)}{h}\right)}^h\cdot {\Delta }^h\frac{1}{e^{h\cdot 2^{k/h}}} \\ \le {\left(\frac{O\left(\frac{k}{h}\right)\cdot \Delta }{e^{2^{k/h}}}\right)}^h={\left(\frac{O\left({\Delta }^2\right)}{e^{2^{c\log \ln \Delta }}}\right)}^h<{\left(\frac{O({\Delta }^2)}{e^{{\ln }^c\Delta }}\right)}^h<{\left(\frac{{\Delta }^3}{{\Delta }^{{\ln }^{c-1}\Delta }}\right)}^h<{\Delta }^{-ch}=n^{-c} \end{gathered}$$

$$\sum _{i=1}^{\infty }4\epsilon \frac{n}{2^i}\le 4\epsilon n<\frac{n}{16}.$$

$$(1+\frac{4^{k-1}-1}{34^{k-1}})\frac{n}{2}-\frac{n}{16}=(1+\frac{1}{3}-\frac{1}{34^{k-1}}-\frac{1}{8})\frac{n}{2}>(1+\frac{1}{8})\frac{n}{2}$$

$$(1+\frac{4^{k-1}+3}{34^{k-1}})\frac{n}{2}+\frac{n}{16}=(1+\frac{1}{3}+\frac{1}{4^{k-1}}+\frac{1}{8})\frac{n}{2}<(1+\frac{7}{8})\frac{n}{2}.$$

$$\displaystyle y_{i}=\left\{\begin{array}[]{ll}0&\mbox{ if }x_{i}\leq a\\ 1&\mbox{ if }x_{i}>a\end{array}\right.$$

$$\mathbf{Pr}\left[\neg \exists x_r\in S_C:x_m<x_r\right]=\mathbf{Pr}\left[\sum _{i=1}^k{X}_i>k/2+n_0\right]\le \exp \left(-\frac{2n_0^2}{3k}\right)\stackrel{n_0=\sqrt{2k\log n}}{=}{n}^{-4/3}.$$

$$\mathbb{E}\left[f_{\text{med}}(n)\right]=\mathbb{E}\left[f_{\text{med}}\left(\mathcal{O}(\sqrt{n\log n})\right)\right]+\mathcal{O}\big{(}\underbrace{\frac{k}{n}\log k}_{\text{Sampled}}+\underbrace{(1-\frac{k}{n})\log_{d}k}_{\text{Not sampled}}+\underbrace{\phantom{\frac{k}{n}}1\phantom{\frac{k}{n}}}_{\text{Misclassified}}\big{)}\,.$$

$$\mathbb{E}\left[f_{\text{rem}}(n)\right]$$

$$\displaystyle+\mathcal{O}\big{(}\underbrace{\log k}_{\text{Sampled}}+\underbrace{\log_{d}n}_{\text{Not sampled}}+\max(\underbrace{\phantom{\frac{k}{n}}d^{2}\phantom{\frac{k}{n}}}_{\scriptstyle\begin{array}[]{c}\text{Pivot in $R_{i}$}\\ i{>}2\end{array}},\underbrace{\frac{nd}{k}}_{\scriptstyle\begin{array}[]{c}\text{Pivot in $R_{j}$}\\ j{\leq}2\end{array}})\big{)}\,,$$

$$\mathbb{E}\left[f_{\text{med}}(n)\right]$$

$$\mathbb{E}\left[f_{\text{rem}}(n)\right]$$

$$\mathbb{E}\left[f_{\text{med}}(n)\right]$$

$$\mathbb{E}\left[f_{\text{rem}}(n)\right]$$

$$\Omega (\sum _{i=0}^{\log n}\log 2^i)=\Omega (\sum _{i=0}^{\log n}i)=\Omega ({\log }^{2}n)$$

$$c{\log }^2{n}_1+\lfloor \log n_2\rfloor +1\ge c{\log }^2(n_1+n_2).$$

$${\log }^2{n}_1+\frac{\log n_2}{c}\ge {\log }^2(n_1+n_2).$$

$$\frac{\log n_2}{c}\ge 2\frac{\log n_1}{n_1}{n}_2,$$

$$\frac{\log n_2}{n_2}\ge 2c\frac{\log n_1}{n_1}.$$

$${\log }^2{n}_1+\frac{1}{c}\ge {\log }^2(n_1+1).$$

$$\frac{1}{c}\ge 2\frac{\log n_1}{n_1}.$$

Full text

Fragile Complexity of Comparison-Based Algorithms111This material is based upon work performed while attending AlgoPARC Workshop on Parallel Algorithms and Data Structures at the University of Hawaii at Manoa, in part supported by the National Science Foundation under Grant No. 1745331.

This work was also partially supported by the Deutsche Forschungsgemeinschaft (DFG) under grants ME 2088/3-2 and ME 2088/4-2, by the Independent Research Fund Denmark, Natural Science, under grant DFF-7014-00041, and by the National Science Foundation under Grant No. CCF-1533823.

Peyman Afshani

  

Rolf Fagerberg

  

David Hammer

  

Riko Jacob

  

Irina Kostitsyna

  

Ulrich Meyer

  

Manuel Penschuck

  

Nodari Sitchinava

1 Introduction

Comparison-based algorithms is a classic and fundamental research area in computer science. Problems studied include minimum, median, sorting, searching, dictionaries, and priority queues, to name a few, and by now a huge body of work exists. The cost measure analyzed is almost always the total number of comparisons needed to solve the problem, either in the worst case or the expected case. Surprisingly, very little work has taken the viewpoint of the individual elements, asking the question: how many comparisons must each element be subjected to?

This question not only seems natural and theoretically fundamental, but is also practically well motivated: in many real world situations, comparisons involve some amount of destructive impact on the elements being compared, hence, keeping the maximum number of comparisons for each individual element low can be important. One example of such a situation is ranking of any type of consumable objects (wine, beer, food, produce), where each comparison reduces the available amount of the objects compared. Here, classical algorithms like QuickSort, which takes a single object and partitions the whole set with it, may use up this pivot element long before the algorithm completes. Another example is sports, where each comparison constitutes a match and takes a physical toll on the athletes involved. If a comparison scheme subjects one contestant to many more matches than others, both fairness to contestants and quality of result are impacted. The selection process could even contradict its own purpose—what is the use of finding a national boxing champion to represent a country at the Olympics if the person is injured in the process? Notice that in both examples above, quality of elements is difficult to measure objectively by a numerical value, hence one has to resort to relative ranking operations between opponents, i.e., comparisons. The detrimental impact of comparisons may also be of less directly physical nature, for instance if it involves a privacy risk for the elements compared, or if bias in the comparison process grows each time the same element is used.

Definition 1.1**.**

We say that a comparison-based algorithm $\mathcal{A}$ has fragile complexity $f({n})$ if each individual input element participates in at most $f({n})$ comparisons. We also say that $\mathcal{A}$ has work $w({n})$ if it performs at most $w({n})$ comparisons in total. We say that a particular element $e$ has fragile complexity $f_{e}(n)$ in $A$ if $e$ participates in at most $f_{e}(n)$ comparisons.

In this paper, we initiate the study of algorithms’ fragile complexity—comparison-based complexity from the viewpoint of the individual elements—and present a number of upper and lower bounds on the fragile complexity for fundamental problems.

1.1 Previous work

One body of work relevant to what we study here is the study of sorting networks, propelled by the 1968 paper of Batcher [6]. In sorting networks, and more generally comparator networks (see Section 2 for a definition), the notions of depth and size correspond to fragile complexity and standard worst case complexity,222For clarity, in the rest of the paper we call standard worst case complexity work. respectively, since a network with depth $f(n)$ and size $w(n)$ easily can be converted into a comparison-based algorithm with fragile complexity $f(n)$ and work $w(n)$.

Batcher gave sorting networks with $\mathcal{O}(\log^{2}n)$ depth and $\mathcal{O}(n\log^{2}n)$ size, based on clever variants of the MergeSort paradigm. A number of later constructions achieve the same bounds [10, 16, 17, 20], and for a long time it was an open question whether better results were possible. In the seminal result in 1983, Ajtai, Komlós, and Szemerédi [2, 3] answered this in the affirmative by constructing a sorting network of $\mathcal{O}(\log n)$ depth and $\mathcal{O}(n\log n)$ size. This construction is quite complex and involves expander graphs [13, 22], which can be viewed as objects encoding pseudorandomness, and which have many powerful applications in computer science and mathematics. The size of the constant factors in the asymptotic complexity of the AKS sorting network prevents it from being practical in any sense. It was later modified by others [8, 12, 18, 21], but finding a simple, optimal sorting network, in particular one not based on expander graphs, remains an open problem. Comparator networks for other problems, such as selection and heap construction have also been studied  [5, 7, 15, 19, 23]. In all these problems the size of the network is super-linear.

As comparator networks of depth $f(n)$ and size $w(n)$ lead to comparison-based algorithms with $f(n)$ fragile complexity and $w(n)$ work, a natural question is, whether the two models are equivalent, or if there are problems for which comparison-based algorithms can achieve either asymptotically lower $f(n)$, or asymptotically lower $w(n)$ for the same $f(n)$.

One could also ask about the relationship between parallelism and fragile complexity. We note that parallel time in standard parallel models generally does not seem to capture fragile complexity. For example, even in the most restrictive exclusive read and exclusive write (EREW) PRAM model it is possible to create $n$ copies of an element $e$ in $\mathcal{O}(\log n)$ time and, thus, compare $e$ to all the other input elements in $\mathcal{O}(\log n)$ time, resulting in $\mathcal{O}(\log n)$ parallel time but $\Omega(n)$ fragile complexity. Consequently, it is not clear whether Richard Cole’s celebrated parallel merge sort algorithm [9] yields a comparison-based algorithm with low fragile complexity as it copies some elements.

1.2 Our contribution

In this paper we present algorithms and lower bounds for a number of classical problems, summarized in Table 1. In particular, we study finding the Minimum (Section 3), the Selection problem (Section 4), and Sorting (Section 5).

Minimum.

The case of the deterministic algorithms is clear: using an adversary lower bound, we show that the minimum element needs to suffer $\Omega(\log n)$ comparisons and a tournament tree trivially achieves this bound (Subsection 3.1). The randomized case, however, is much more interesting. We obtain a simple algorithm where the probability of the minimum element suffering $k$ comparisons is doubly exponentially low in $k$, roughly $1/2^{2^{k}}$ (see Subsection 3.2). As a result, the $\Theta(\log n)$ deterministic fragile complexity can be lowered to $O(1)$ expected or even $O(\log\log n)$ with high probability. We also show this latter high probability case is lower bounded by $\Omega(\log\log n)$ (Subsection 3.3). Furthermore, we can achieve a trade-off between the fragile complexity of the minimum element and the other elements. Here $\Delta=\Delta(n)$ is a parameter we can choose freely that basically upper bounds the fragile complexity of the non-minimal elements. We can find the minimum with $O(\log_{\Delta}n)$ expected fragile complexity while all the other elements suffer $O(\Delta+\log_{\Delta}n)$ comparisons (Subsection 3.3). Furthermore, this is tight: we show an $\Omega(\log_{\Delta}n)$ lower bound for the expected fragile complexity of the minimum element where the maximum fragile complexity of non-minimum elements is at most $\Delta$.

Selection.

Minimum finding is a special case of the selection problem where we are interested in finding an element of a given rank. As a result, all of our lower bounds apply to this problem as well. Regarding upper bounds, the deterministic case is trivial if we allow for $O(n\log n)$ work (via sorting). We show that this can be reduced to $O(n)$ time while keeping the fragile complexity of all the elements at $O(\log n)$ (Section 4). Once again, randomization offers a substantial improvement: e.g., we can find the median in $O(n)$ expected work and with $O(\log\log n)$ expected fragile complexity while non-median elements suffer $O(\sqrt{n})$ expected comparisons, or we can find the median in $O(n)$ expected work and with $O(\log n/\log\log n)$ expected fragile complexity while non-median elements suffer $O(\log^{2}{n})$ expected comparisons.

Sorting and other results.

The deterministic selection, sorting, and heap construction fragile complexities follow directly from the classical results in comparator networks [3, 7]. However, we show a separation between comparator networks and comparison-based algorithms for the problem of Median (Section 4) and Heap Construction (Section 6), in the sense that depth/fragile complexity of $\mathcal{O}(\log n)$ can be achieved in $\mathcal{O}(n)$ work for comparison-based algorithms, but requires $\Omega(n\log n)$ [5] and $\Omega(n\log\log n)$ [7] sizes for comparator networks for the two problems, respectively. For sorting the two models achieve the same complexities: $\mathcal{O}(\log n)$ depth/fragile complexity and $\mathcal{O}(n\log n)$ size/work, which are the optimal bounds in both models due to the $\Omega(\log n)$ lower bound on fragile complexity for Minimum (Theorem 3.1) and the standard $\Omega(n\log n)$ lower bound on work for comparison-based sorting. However, it is an open problem whether these bounds can be achieved by simpler sorting algorithms than sorting networks, in particular whether expander graphs are necessary. One intriguing conjecture could be that any comparison-based sorting algorithm with $\mathcal{O}(\log n)$ fragile complexity and $\mathcal{O}(n\log n)$ work implies an expander graph. This would imply expanders, optimal sorting networks and fragile-optimal comparison-based sorting algorithms to be equivalent, in the sense that they all encode the same level of pseudorandomness.

We note that our lower bound of $\Omega(\log^{2}n)$ on the fragile complexity of MergeSort (Theorem 5.5) implies the same lower bound on the depth of any sorting network based on binary merging, which explains why many of the existing simple sorting networks have $\Theta(\log^{2}n)$ depth. Finally, our analysis of MergeSort on random inputs (Theorem 5.11) shows a separation between deterministic and randomized fragile complexity for such algorithms. In summary, we consider the main contributions of this paper to be:

• •

the introduction of the model of fragile complexity, which we find intrinsically interesting, practically relevant, and surprisingly overlooked

• •

the separations between this model and the model of comparator networks

• •

the separations between the deterministic and randomized setting within the model

• •

the lower bounds on randomized minimum finding

2 Definitions

**Comparator networks. ** A comparator network $\mathcal{N}$ is constructed of comparators each consisting of two inputs and two (ordered) outputs. The value of the first output is the minimum of the two inputs and the value of the second output is the maximum of the two inputs. By this definition a comparator network $\mathcal{N}_{n}$ on $n$ inputs also consists of $n$ outputs. Figure 1 demonstrates a common visualization of comparator networks with values as horizontal wires and comparators represented by vertical arrows between pairs of wires. Each arrow points to the output that returns the minimum input value. Inputs are on the left and outputs on the right. The size of the comparator network is defined as the number of comparators in it, while its depth is defined as the number of comparators on the longest path from an input to an output.

We note that a comparator network is straightforward to execute as a comparison-based algorithm by simulating its comparators sequentially from left to right (see Figure 1), breaking ties arbitrarily. If the network has depth $f(n)$ and size $g(n)$, the comparison-based algorithm clearly has fragile complexity $f(n)$ and work $g(n)$.

**Networks for problems. ** We define the set of inputs to the comparator network $\mathcal{N}$ by $\mathcal{I}$ and the outputs by $\mathcal{N}(\mathcal{I})$. We use the notation $\mathcal{N}(\mathcal{I})^{i}$ for $0\leq i\leq n-1$, to represent the $i$-th output and $\mathcal{N}(\mathcal{I})^{i:j}$ for $0\leq i\leq j\leq n-1$ to represent the ordered subset of the $i$-th through $j$-th outputs.

An $(n)$-sorting network is a comparator network $\mathcal{N}_{n}$ such that $\mathcal{N}_{n}(\mathcal{I})^{t}$ carries the $t$-th smallest input value for all $t$. We say such a network solves the $(n)$-sorting problem.

An $(n,t)$-selection network is a comparator network $\mathcal{N}_{n,t}$ such that $\mathcal{N}_{n,t}(\mathcal{I})^{0}$ carries the $t$-th smallest input value. We say such a network solves the $(n,t)$-selection problem.

An $(n,t)$-partition network is a comparator network $\mathcal{N}_{n,t}$, such that $\mathcal{N}_{n,t}(\mathcal{I})^{0:t-1}$ carry the $t$ smallest input values.333Brodal and Pinotti [7] call it an $(n,t)$-selection network, but we feel $(n,t)$-partition network is a more appropriate name. We say such a network solves the $(n,t)$-partition problem.

Clearly, an $(n,t)$-selection problem is asymptotically no harder than $(n,t)$-partition problem: let $\mathcal{N}^{\downarrow}_{n,t}(\mathcal{I})$ denote an $(n,t)$-partition network with all comparators reversed; then $\mathcal{N}^{\prime}_{n,t}(\mathcal{I})=\mathcal{N}^{\downarrow}_{t,t-1}(\mathcal{N}_{n,t}(\mathcal{I}))$ is an $(n,t)$-selection network. However, the converse is not clear: given a value of the $t$-th smallest element as one of the inputs, it is not obvious how to construct an $(n,t)$-partition network with smaller size or depth. In Section 4 we will show that the two problems are equivalent: every $(n,t)$-selection network also solves the $(n,t)$-partition problem.

**Rank. ** Given a set $X$, the rank of some element $e$ in $X$, denoted by $rank_{X}(e)$, is equal to the size of the subset of $X$ containing the elements that are no larger than $e$. When the set $X$ is clear from the context, we will omit the subscript $X$ and simply write $rank(e)$.

3 Finding the minimum

3.1 Deterministic Algorithms

As a starting point, we study deterministic algorithms that find the minimum among an input of $n$ elements. Our results here are simple but they act as interesting points of comparison against the subsequent non-trivial results on randomized algorithms.

Theorem 3.1**.**

The fragile complexity of finding the minimum of $n$ elements is $\lceil\log n\rceil$.

Proof 3.2**.**

The upper bound follows trivially from the application of a balanced tournament tree. We thus focus on the lower bound. Let $S$ be a set of $n$ elements, and $\mathcal{A}$ be a deterministic comparison-based algorithm that finds the minimum element of $S$. We describe an adversarial strategy for resolving the comparisons made by $\mathcal{A}$ that leads to the lower bound.

Consider a directed graph $G$ on $n$ nodes corresponding to the elements of $S$. With a slight abuse of notation, we use the same names for elements of $S$ and the associated nodes in graph $G$. The edges of $G$ correspond to comparisons made by $\mathcal{A}$, and are either black or red. Initially $G$ has no edges. If $\mathcal{A}$ compares two elements, we insert a directed edge between the associated nodes pointing toward the element declared smaller by the adversarial strategy. Algorithm $\mathcal{A}$ correctly finds the minimum element if and only if, upon termination of $\mathcal{A}$, the resulting graph $G$ has only one sink node.

Consider the following adversarial strategy to resolve comparisons made by $\mathcal{A}$: if both elements are sinks in $G$, the element that has already participated in more comparisons is declared smaller; if only one element is a sink in $G$, this element is declared smaller; and if neither element is a sink in $G$, the comparison is resolved arbitrarily (while conforming to the existing partial order).

We color an edge in $G$ red if it corresponds to a comparison between two sinks; otherwise, we color the edge black. For each element $i$, consider its in-degree $d_{i}$ and the number of nodes $r_{i}$ in $G$ (incl. $i$ itself) from which $i$ is reachable by a directed path of only red edges.

We show by induction that $r_{i}\leq 2^{d_{i}}$ for all sinks in $G$. Initially, $r_{i}=1\leq 1=2^{d_{i}}$ for all $i$. Let algorithm $\mathcal{A}$ compare two elements $i$ and $j$, where $i$ is a sink, and let the adversarial strategy declare $i$ to be smaller than $j$. Then, the resulting in-degree of $i$ is $d_{i}+1$. If the new edge is black, the number of nodes from which $i$ is reachable via red edges does not change, and the inequality holds trivially. If the new edge is red, the resulting number of nodes from which $i$ is reachable is $r_{i}+r_{j}\leq 2^{d_{i}}+2^{d_{j}}\leq 2^{d_{i}+1}$. Therefore, when $\mathcal{A}$ terminates with the only sink $v$ in $G$, which represents the minimum element, with degree $d_{v}\geq\lceil\log r_{v}\rceil$. The theorem follows by observing that a tournament tree is an instance where $r_{v}=n$.

Observe that in addition to returning the minimum, the balanced tournament tree can also return the second smallest element, without any increase to the fragile complexity of the minimum. We refer to this deterministic algorithm that returns the smallest and the second smallest element of a set $X$ as TournamentMinimum($X$).

Corollary 3.3**.**

For any deterministic algorithm $\mathcal{A}$ that finds the median of $n$ elements, the fragile complexity of the median element is at least $\lceil\log n\rceil-1$.

Proof 3.4**.**

By a standard padding argument with $n-1$ small elements.

3.2 Randomized Algorithms for Finding the Minimum

We now show that finding the minimum is provably easier for randomized algorithms than for deterministic algorithms. We define $f_{\text{min}}$ as the fragile complexity of the minimum and $f_{\text{rem}}$ as the maximum fragile complexity of the remaining elements. For deterministic algorithms we have shown that $f_{\text{min}}\geq\log n$ regardless of $f_{\text{rem}}$. This is very different in the randomized setting. In particular, we first show that we can achieve $\mathbb{E}\left[f_{\text{min}}\right]=O(1)$ and $f_{\text{min}}=O(1)+\log\log n$ whp. (in Theorem 3.25 we show that this bound is also tight).

1:procedure SampleMinimum($X$) $\triangleright$ Returns the smallest and 2nd smallest element of $X$

2:     if $|X|\leq 8$  return TournamentMinimum($X$)      

3:     Let $A\subset X$ be a uniform random sample of $X$, with $|A|={\left\lceil{|X|/2}\right\rceil}$

4:     Let $B\subset A$ be a uniform random sample of $A$, with $|B|={\left\lfloor{|X|^{2/3}}\right\rfloor}$

5:$\triangleright$ The minimum is either in (i) $C\subseteq X\setminus A$, (ii) $D\subseteq A\setminus B$ or (iii) $B$

6:     $(b_{1},b_{2})=$ SampleMinimum($B$) $\triangleright$ the minimum participates only in case (iii)

7:     Let $D=\{x\in A\setminus B\mid x<b_{2}\}$ $\triangleright$ the minimum is compared once only in case (ii)

8:     Let $(a^{\prime}_{1},a^{\prime}_{2})=$ SampleMinimum($D$) $\triangleright$ only case (ii)

9:     Let $(a_{1},a_{2})=$ TournamentMinimum($a^{\prime}_{1},a^{\prime}_{2},b_{1},b_{2}$) $\triangleright$ case (ii) and (iii)

10:     Let $C=\{x\in X\setminus A\mid x<a_{2}\}$ $\triangleright$ only case (i)

11:     Let $(c_{1},c_{2})=$ TournamentMinimum($C$) $\triangleright$ only case (i)

12:     return TournamentMinimum($a_{1},a_{2},c_{1},c_{2}$) $\triangleright$ always

First, we show that this algorithm can actually find the minimum with expected constant number of comparisons. Later, we show that the probability that this algorithm performs $t$ comparisons on the minimum drops roughly doubly exponentially on $t$.

We start with the simple worst-case analysis.

Lemma 3.5**.**

Algorithm SampleMinimum($X$) achieves $f_{\text{min}}\leq 3\log|X|$ in the worst case.

Proof 3.6**.**

First, observe that the smallest element in Lines 9 and 12 participates in at most one comparison because pairs of elements are already sorted. Then the fragile complexity of the minimum is defined by the maximum of the three cases:

1. (i)

One comparison each in Lines 10 and 12, plus (by Theorem 3.1) ${\left\lceil{\log|C|}\right\rceil}\leq\log|X|$ comparisons in Line 11. 2. (ii)

One comparison each in Lines 7, 9, and 12, plus the recursive call in line 8. 3. (iii)

One comparison each in Lines 6, 9, and 12, plus the recursive call in line 6.

The recursive calls in lines 8 and 6 are on at most $|X|/2$ elements because $B\subset A$, $D\subset A$, and $|A|={\left\lceil{|X|/2}\right\rceil}$. Consequently, the fragile complexity of the minimum is governed by

[TABLE]

which solves to $T(n)\leq 3\log n$.

Lemma 3.7**.**

Assume that in Algorithm SampleMinimum, the minimum $y$ is in $X\setminus A$, i.e. we are in case (i). Then $\mathbf{Pr}[|C|=k\mid y\not\in A]\leq\frac{k}{2^{k}}$ for any $k\geq 1$ and $n\geq 7$.

Proof 3.8**.**

There are $\binom{n-1}{{\left\lceil{n/2}\right\rceil}}$ possible events of choosing a random subset $A\subset X$ of size ${\left\lceil{n/2}\right\rceil}$ s.t. $y\not\in A$. Let us count the number of the events $\{|C|=k\mid y\not\in A\}$, which is equivalent to $a_{2}$, the second smallest element of $A$, being larger than exactly $k+1$ elements of $X$.

For simplicity of exposition, consider the elements of $X=\{x_{1},\dots,x_{n}\}$ in sorted order. The minimum $y=x_{1}\not\in A$, therefore, $a_{1}$ (the smallest element of $A$) must be one of the $k$ elements $\{x_{2},\dots,x_{k+1}\}$. By the above observation, $a_{2}=x_{k+2}$. And the remaining ${\left\lceil{n/2}\right\rceil}-2$ elements of $A$ are chosen from among $\{x_{k+3},\dots,x_{n}\}$. Therefore,

[TABLE]

Rearranging the terms, we get:

[TABLE]

There are two cases to consider:

[TABLE]

[TABLE]

Theorem 3.9**.**

Algorithm SampleMinimum achieves $\mathbb{E}\left[f_{\text{min}}\right]\leq 9$.

Proof 3.10**.**

By induction on the size of $X$. In the base case $|X|\leq 8$, clearly $f_{\text{min}}\leq 3$, implying the theorem. Now assume that the calls in Line 8 and Line 6 have the property that $\mathbb{E}\left[f(b_{1})\right]\leq 9$ and $\mathbb{E}\left[f(a^{\prime}_{1})\right]\leq 9$. Both in case (ii) and case (iii), the expected number of comparisons of the minimum is $\leq 9+3$. Case (i) happens with probability at least 1/2. In this case, the expected number of comparisons is 2 plus the ones from Line 11. By Lemma 3.7 we have $\mathbf{Pr}[|C|=k\mid\hbox{case (i)}]\leq k2^{-k}$. Because TournamentMinimum (actually any algorithm not repeating the same comparison) uses the minimum at most $k-1$ times, the expected number of comparisons in Line 11 is $\sum_{k=1}^{\left\lfloor{n/2}\right\rfloor}(k-1)k2^{-k}\leq\sum_{k=1}^{\infty}(k-1)k2^{-k}\leq 4$. Combining the bounds we get $\mathbb{E}\left[f_{\text{min}}\right]\leq\frac{9+3}{2}+\frac{2+4}{2}=9$.

Observe that the above proof did not use anything about the sampling of $B$, and also did not rely on TournamentMinimum.

Lemma 3.11**.**

For $|X|>2$ and any $\gamma>1$: $\mathbf{Pr}\left[|D|\geq\gamma|X|^{1/3}\right]<|X|\exp(-\Theta(\gamma))$

Proof 3.12**.**

Let $n=|X|$, $a=|A|={\left\lceil{n/2}\right\rceil}$ and $b=|B|={\left\lfloor{n^{2/3}}\right\rfloor}$. The construction of the set $B$ can be viewed as the following experiment. Consider drawing without replacement from an urn with $b$ blue and $a-b$ red marbles. The $i$-th smallest element of $A$ is chosen into $B$ iff the $i$-th draw from the urn results in a blue marble. Then $|D|\geq\gamma|X|^{1/3}=\gamma n^{1/3}$ implies that this experiment results in at most one blue marble among the first $t=\gamma n^{1/3}$ draws. There are precisely $t+1$ elementary events that make up the condition $|D|\geq t$, namely that the $i$-th draw is a blue marble, and where $i=0$ stands for the event “all $t$ marbles are red”. Let us denote the probabilities of these elementary events as $p_{i}$.

Observe that each $p_{i}$ can be expressed as a product of $t$ factors, at least $t-1$ of which stand for drawing a red marble, each upper bounded by $1-\frac{b-1}{a}$. The remaining factor stands for drawing the first blue marble (from the urn with $a-i$ marbles, $b$ of which are blue), or another red marble. In any case we can bound

[TABLE]

Summing the $t+1$ terms, and observing $t+1<n$ if the event can happen at all, we get

[TABLE]

Theorem 3.13**.**

There is a positive constant $c$, such that for any parameter $t\geq c$, the minimum in the Algorithm SampleMinimum($X$) participates in at most $O(t+\log\log|X|)$ comparisons with probability at least $1-\exp(-2^{t})2\log\log|X|$.

Proof 3.14**.**

Let $n=|X|$ and $y$ be the minimum element. In each recursion step, we have one of three cases: (i) $y\in C\subseteq X\setminus A$, (ii) $y\in D\subseteq A\setminus B$ or (iii) $y\in B$. Since the three sets are disjoint, the minimum always participates in at most one recursive call. Tracing only the recursive calls that include the minimum, we use the superscript $X^{(i)},A^{(i)},B^{(i)},C^{(i)}$, and $D^{(i)}$ to denote these sets at depth $i$ of the recursion.

Let $h$ be the first recursive level when $y\in C^{(h)}$, i.e., $y\not\in A^{(h)}$. It follows that $y$ will not be involved in the future recursive calls because it is in a single call to TournamentMinimum. Thus, at this level of recursion, the number of comparisons that $y$ will accumulate is equal to $O(1)+\log|C^{(h)}|$. To bound this quantity, let $k=4\cdot 2^{t}$. Then, by Lemma 3.7, $\mathbf{Pr}[|C^{(h)}|>k]\leq k2^{-k}=4\cdot 2^{t}\cdot 2^{-4\cdot 2^{t}}=4\cdot 2^{t}\cdot 4^{-2^{t}}\cdot 4^{-2^{t}}$. Since $4x4^{-x}\leq 1$ for any $x\geq 1$, $\mathbf{Pr}[|C^{(h)}|>k]\leq 4^{-2^{t}}$ for any $t\geq 0$. I.e., the number of comparisons that $y$ participates in at level $h$ is at most $O(1)+\log k=O(1)+t$ with probability at least $1-4^{-2^{t}}\geq 1-\exp(-2^{t})$.

Thus, it remains to bound the number of comparisons involving $y$ at the recursive levels $i\in[1,h-1]$. In each of these recursive levels $y\not\in C^{(i)}$, which only leaves the two cases: (ii) $y\in D^{(i)}\subseteq A^{(i)}\setminus B^{(i)}$ and (iii) $y\in B^{(i)}$. The element $y$ is involved in at most $O(1)$ comparisons in lines 7, 9 and 12. The two remaining lines of the algorithm are lines 6 and 8 which are the recursive calls. We differentiate two types of recursive calls:

• •

Type 1: $|X^{(i)}|\leq 2^{4t}$. In this case, by Lemma 3.5, the algorithm will perform $O(t)$ comparisons at the recursive level $i$, as well as any subsequent recursive levels.

• •

Type 2: $|X^{(i)}|>2^{4t}$. In this case, by Lemma 3.11 on the set $X^{(i)}$ and $\gamma=|X^{(i)}|^{1/3}$ we get:

[TABLE]

Note that since $|X^{(i)}|^{1/3}>2^{t}$, by the definition of the $\Theta$-notation, there exists a positive constant $c$, such that $\exp\left(-\Theta\left(|X^{(i)}|^{1/3}\right)\right)<\exp(-2^{t})$. Thus, it follows that with probability $1-\exp(-2^{t})$, we will recurse on a subproblem of size at most $\gamma|X^{(i)}|^{1/3}\leq|X^{(i)}|^{2/3}$. Let $G_{i}$ be this (good) event, and thus $\mathbf{Pr}[G_{i}]\geq 1-\exp(-2^{t})$.

Observe that the maximum number of times we can have good events of type 2 is very limited. With every such good event, the size of the subproblem decreases significantly and thus eventually we will arrive at a recursive call of type 1. Let $j$ be this maximum number of “good” recursive levels of type 2. The problem size at the $j$-th such recursive level is at most $n^{\left(2/3\right)^{j-1}}$ and we must have that $n^{\left(2/3\right)^{j-1}}>2^{4t}$ which reveals that we must have $j=O\left(\log\log n\right)$.

We are now almost done and we just need to use a union bound. Let $G$ be the event that at the recursive level $h$, we perform at most $O(1)+t$ comparisons, and all the recursive levels of type 2 are good. $G$ is the conjunction of at most $j+1$ events and as we have shown, each such event holds with probability at least $1-\exp(-2^{t})$. Thus, it follows that $G$ happens with probability $1-(j+1)\exp(-2^{t})>1-2\log\log n\exp(-2^{t})$. Furthermore, our arguments show that if $G$ happens, then the minimum will only particpate in $O(t+j)=O\left(t+\log\log n\right)$ comparisons.

The major strengths of the above algorithm is the doubly exponential drop in probability of comparing the minimum with too many elements. Based on it, we can design another simple algorithm to provide a smooth trade-off between $f_{\text{min}}$ and $f_{\text{rem}}$. Let $2\leq\Delta\leq n$ be an integral parameter. We will design an algorithm that achieves $\mathbb{E}\left[f_{\text{min}}\right]=O(\log_{\Delta}n)$ and $f_{\text{min}}=O(\log_{\Delta}n\cdot\log\log\Delta)$ whp, and $f_{\text{rem}}=\Delta+O(\log_{\Delta}n\cdot\log\log\Delta)$ whp. For simplicity we assume $n$ is a power of $\Delta$. We build a fixed tournament tree $T$ of degree $\Delta$ and of height $\log_{\Delta}n$ on $X$. For a node $v\in T$, let $X(v)$ be the set of values in the subtree rooted at $v$. The following code computes $m(v)$, the minimum value of $X(v)$, for every node $v$.

1:procedure TreeMinimumΔ($X$)

2:     For every leaf $v$, set $m(v)$ equal to the single element of $X(v)$.

3:     For every internal node $v$ with $\Delta$ children $u_{1},\dots,u_{\Delta}$ where the values $m(u_{1}),\dots,m(u_{\Delta})$ are known, compute $m(v)$ using SimpleMinimum algorithm on input $\left\{m(u_{1}),\dots,m(u_{\Delta})\right\}$.

4:     Repeat the above step until the minimum of $X$ is computed.

The correctness of TreeMinimumΔ is trivial. So it remains to analyze its fragile complexity.

Theorem 3.15**.**

In TreeMinimumΔ, $\mathbb{E}\left[f_{\text{min}}\right]=O(\log_{\Delta}n)$ and $\mathbb{E}\left[f_{\text{rem}}\right]=\Delta+O(\log_{\Delta}n)$. Furthermore, with high probability, $f_{\text{min}}=O\left(\frac{\log n\log\log\Delta}{\log\Delta}\right)$ and $f_{\text{rem}}=O\left(\Delta+\frac{\log n\log\log\Delta}{\log\Delta}\right)$.

Proof 3.16**.**

First, observe that $\mathbb{E}\left[f_{\text{min}}\right]=O(\log_{\Delta}n)$ is an easy consequence of Theorem 3.9. Now we focus on high probability bounds. Let $k=c\cdot h\log\ln\Delta$, and $h=\log_{\Delta}n$ for a large enough constant $c$. There are $h$ levels in $T$. Let $\mathbf{f}_{i}$ be the random variable that counts the number of comparisons the minimum participates in at level $i$ of $T$. Observe that these are independent random variables. Let $f_{1},\dots,f_{h}$ be integers such that $f_{i}\geq 1$ and $\sum_{i=1}^{h}f_{i}=k$, and let $c^{\prime}$ be the constant hidden in the big-$O$ notation of Theorem 3.13. Use Theorem 3.13 $h$ times (with $n$ set to $\Delta$, and $t=f_{i}$), and also bound $2\log\log\Delta<\Delta$ to get

[TABLE]

where the last inequality follows from the inequality of arithmetic and geometric means (specifically, observe that $\sum_{i=1}^{h}2^{f_{i}}$ is minimized when all $f_{i}$’s are distributed evenly).

Now observe that the total number of different integral sequences $f_{1},\dots,f_{h}$ that sum up to $k$ is bounded by $h+k\choose h$ (this is the classical problem of distributing $k$ identical balls into $h$ distinct bins). Thus, we have

[TABLE]

where in the last step we bound $(\ln\Delta)^{c-1}-3>c$ for large enough $c$ and $\Delta\geq 3$. This is a high probability bound for $f_{\text{min}}$. To bound $f_{\text{rem}}$, observe that for every non-minimum element $x$, there exists a lowest node $v$ such that $x$ is not $m(v)$. If $x$ is not passed to the ancestors of $v$, $x$ suffers at most $\Delta$ comparisons in $v$, and below $v$ $x$ behaves like the minimum element, which means that the above analysis applies. This yields that whp we have $f_{\text{rem}}=\Delta+O\left(\frac{\log n\log\log\Delta}{\log\Delta}\right)$.

3.3 Randomized Lower Bounds for Finding the Minimum

3.3.1 Expected Lower Bound for the Fragile Complexity of the Minimum.

The following theorem is our main result.

Theorem 3.17**.**

In any randomized minimum finding algorithm with fragile complexity of at most $\Delta$ for any element, the expected fragile complexity of the minimum is at least $\Omega(\log_{\Delta}n)$.

Note that this theorem implies the fragile complexity of finding the minimum:

Corollary 3.18**.**

Let $f(n)$ be the expected fragile complexity of finding the minimum (i.e. the smallest function such that some algorithm achieves $f(n)$ fragile complexity for all elements (minimum and the rest) in expectation). Then $f(n)=\Theta(\frac{\log n}{\log\log n})$.

Proof 3.19**.**

Use Theorem 3.15 as the upper bound and Theorem 3.17, both with $\Delta=\frac{\log n}{\log\log n}$, observing that if $f(n)$ is an upper bound that holds with high probability, it is also an upper bound on the expectation.

To prove Theorem 3.17 we give a lower bound for a deterministic algorithm $\mathcal{A}$ on a random input of $n$ values, $x_{1},\dots,x_{n}$ where each $x_{i}$ is chosen iid and uniformly in $(0,1)$. By Yao’s minimax principle, the lower bound on the expected fragile complexity of the minimum when running $\mathcal{A}$ also holds for any randomized algorithm.

We prove our lower bound in a model that we call “comparisons with additional information (CAI)”: if the algorithm $\mathcal{A}$ compares two elements $x_{i}$ and $x_{j}$ and it turns out that $x_{i}<x_{j}$, then the value $x_{j}$ is revealed to the algorithm. Clearly, the algorithm can only do better with this extra information. The heart of the proof is the following lemma which also acts as the “base case” of our proof.

Lemma 3.20**.**

Let $\Delta$ be an upper bound on $f_{\text{rem}}$. Consider $T$ values $x_{1},\dots,x_{T}$ chosen iid and uniformly in $(0,b)$. Consider a deterministic algorithm $\mathcal{A}$ in CAI model that finds the minimum value $y$ among $x_{1},\dots,x_{T}$. If $T>1000\Delta$, then with probability at least $\frac{7}{10}$ $\mathcal{A}$ will compare $y$ against an element $x$ such that $x\geq b/(100\Delta).$

Proof 3.21**.**

By simple scaling, we can assume $b=1$. Let $p$ be the probability that $\mathcal{A}$ compares $y$ against a value larger than $1/(100\Delta)$. Let $I_{\mbox{\footnotesize small}}$ be the set of indices $i$ such that $x_{i}<1/(100\Delta)$. Let $\mathcal{A}^{\prime}$ be a deterministic algorithm in CAI model such that:

• •

$\mathcal{A}^{\prime}$* is given all the indices in $I_{\mbox{\footnotesize small}}$ (and their corresponding values) except for the index of the minimum. We call these the known values.*

• •

$\mathcal{A}^{\prime}$* minimizes the probability $p^{\prime}$ of comparing the $y$ against a value larger than $1/(100\Delta)$.*

• •

$\mathcal{A}^{\prime}$* finds the minimum value among the unknown values.*

Since $p^{\prime}\leq p$, it suffices to bound $p^{\prime}$ from below. We do this in the remainder of the proof.

Observe that the expected number of values $x_{i}$ such that $x_{i}<1/(100\Delta)$ is $T/(100\Delta)$. Thus, by Markov’s inequality, $\mathbf{Pr}[|I_{\mbox{\footnotesize small}}|\leq T/(10\Delta)]\geq\frac{9}{10}$. Let’s call the event $|I_{\mbox{\footnotesize small}}|\leq T/(10\Delta)$ the good event. For algorithm $\mathcal{A}^{\prime}$ all values smaller than $1/(100\Delta)$ except for the minimum are known. Let $U$ be the set of indices of the unknown values. Observe that a value $x_{i}$ for $i\in U$ is either the minimum or larger than $1/(100\Delta)$, and that $|U|=T-|I_{\mbox{\footnotesize small}}|+1>\frac{9}{10}T$ (using $\Delta\geq 1$) in the good event. Because $\mathcal{A}^{\prime}$ is a deterministic algorithm, the set $U$ is split into set $F$ of elements that have their first comparison against a known element, and set $W$ of those that are first compared with another element with index in $U$. Because of the global bound $\Delta$ on the fragile complexity of the known elements, we know $|F|<\Delta\cdot|I_{\mbox{\footnotesize small}}|\leq\Delta T/(10\Delta)=T/10$. Combining this with the probability of the good event, by union bound, the probability of the minimum being compared with a value greater than $1/(100\Delta)$ is at least $1-(1-\frac{9}{10})-(1-\frac{8}{9})\geq 7/10$.

Based on the above lemma, our proof idea is the following. Let $G=100\Delta$. We would like to prove that on average $\mathcal{A}$ cannot avoid comparing the minimum to a lot of elements. In particular, we show that, with constant probability, the minimum will be compared against some value in the range $[G^{-i},G^{-i+1}]$ for every integer $i$, $1\leq i\leq\frac{\log_{G}n}{2}$. Our lower bound then follows by an easy application of the linearity of expectations. Proving this, however, is a little bit tricky. However, observe that Lemma 3.20 already proves this for $i=1$. Next, we use the following lemma to apply Lemma 3.20 over all values of $i$, $1\leq i\leq\frac{\log_{G}n}{2}$.

Lemma 3.22**.**

For a value $b$ with $0<b<1$, define $p_{k}={n\choose k}b^{i}(1-b)^{n-k}$, for $0\leq k\leq n$. Choosing $x_{1},\dots,x_{n}$ iid and uniformly in $(0,1)$ is equivalent to the following: with probability $p_{k}$, uniformly sample a set $I$ of $k$ distinct indices in $\left\{1,\dots,n\right\}$ among all the subsets of size $k$. For each $i\in I$, pick $x_{i}$ iid and uniformly in $(0,b)$. For each $i\not\in I$, pick $x_{i}$ iid and uniformly in $(b,1)$.

Proof 3.23**.**

It is easy to see that choosing $x_{1},\dots,x_{n}$ iid uniformly in $(0,1)$ is equivalent to choosing a point $X$ uniformly at random inside an $n$ dimensional unit cube $(0,1)^{n}$. Therefore, we will prove the equivalence between (i) the distribution defined in the lemma, and (ii) choosing such point $X$.

Let $Q$ be the $n$-dimensional unit cube. Subdivide $Q$ into $2^{n}$ rectangular region defined by the Cartesian product of intervals $(0,b)$ and $(b,1)$, i.e., $\left\{(0,b),(b,1)\right\}^{n}$ (or alternatively, bisect $Q$ with $n$ hyperplanes, with the $i$-th hyperplane perpendicular to the $i$-th axis and intersecting it at coordinate equal to $b$).

Consider the set $R_{k}$ of rectangles in $\left\{(0,b),(b,1)\right\}^{n}$ with exactly $k$ sides of length $b$ and $n-k$ sides of length $1-b$. Observe that for every choice of $k$ (distinct) indices $i_{1},\dots,i_{k}$ out of $\left\{1,\dots,n\right\}$, there exists exactly one rectangle $r$ in $R_{k}$ such that $r$ has side length $b$ at dimensions $i_{1},\dots,i_{k}$, and all the other sides of $r$ has length $n-k$. As a result, we know that the number of rectangles in $R_{k}$ is ${n\choose k}$ and the volume of each rectangle in $R_{k}$ is $b^{k}(1-b)^{k}$. Thus, if we choose a point $X$ randomly inside $Q$, with probability $p_{k}$ it will fall inside a rectangle $r$ in $R_{k}$; furthermore, conditioned on this event, the dimensions $i_{1},\dots,i_{k}$ where $r$ has side length $b$ is a uniform subset of $k$ distinct indices from $\left\{1,\dots,n\right\}$.

Remember that our goal was to prove that with constant probability, the minimum will be compared against some value in the range $[G^{-i},G^{-i+1}]$ for every integer $i$, $1\leq i\leq\frac{\log_{G}n}{2}$. We can pick $b=G^{-i+1}$ and apply Lemma 3.22. We then observe that it is very likely that the set of indices $I$ that we are sampling in Lemma 3.22 will contain many indices. For every element $x_{i}$, $i\in I$, we are sampling $x_{i}$ independently and uniformly in $(0,b)$ which opens the door for us to apply Lemma 3.20. Then we argue that Lemma 3.20 would imply that with constant probability the minimum will be compared against a value in the range $(b/G,b)=(G^{-i},G^{-i+1})$. The lower bound claim of Theorem 3.17 then follows by invoking the linearity of expectations.

We are ready to prove that the minimum element will have $\Omega(\log_{\Delta}n)$ comparisons on average.

Proof 3.24** (Proof of Theorem 3.17).**

First, observe that we can assume $n\geq(100,000\Delta)^{2}$ as otherwise we are aiming for a trivial bound of $\Omega(1)$. We create an input set of $n$ values $x_{1},\dots,x_{n}$ where each $x_{i}$ is chosen iid and uniformly in $(0,1)$. Let $G=100\Delta$. Consider an integer $i$ such that $1\leq i<\frac{\log_{G}n}{2}$. We are going to prove that with constant probability, the minimum will be compared against a value in the range $(G^{-i},G^{-i+1})$, which, by linearity of expectation, shows the stated $\Omega(\log_{\Delta}n)$ lower bound for the fragile complexity of the minimum.

Consider a fixed value of $i$. Let $S$ be the set of indices with values that are smaller than $G^{-i+1}$. Let $p$ be the probability that $\mathcal{A}$ compares the minimum against an $x_{j}$ with $j\in S$ such that $x_{j}\geq G^{-i}$. To prove the theorem, it suffices to prove that $p$ is lower bounded by a constant. Now consider an algorithm $\mathcal{A}^{\prime}$ that finds the minimum but for whom all the values other than those in $S$ have been revealed and furthermore, assume $\mathcal{A}^{\prime}$ minimizes the probability of comparing the minimum against an element $x\geq G^{-i}$ (in other words, we pick the algorithm which minimizes this probability, among all the algorithms). Clearly, $p^{\prime}\leq p$. In the rest of the proof we will give a lower bound for $p^{\prime}$.

Observe that $|S|$ is a random variable with binomial distribution. Hence $\mathbb{E}\left[|S|\right]=nG^{-i+1}>\sqrt{n}$ where the latter follows from $i<\frac{\log_{G}n}{2}$. By the properties of the binomial distribution we have that $\mathbf{Pr}\left[|S|<\frac{\mathbb{E}\left[|S|\right]}{100}\right]<\frac{1}{10}.$ Thus, with probability at least $\frac{9}{10}$, we will have the “good” event that $|S|\geq\frac{\mathbb{E}\left[|S|\right]}{100}\geq\frac{\sqrt{n}}{100}$.

In case of the good event, Lemma 3.22 implying that conditioned on $S$ being the set of values smaller than $G^{-i+1}$, each value $x_{j}$ with $j\in S$ is distributed independently and uniformly in the range $(0,G^{-i+1})$. As a result, we can now invoke Lemma 3.20 on the set $S$ with $T=|S|$. Since $n\geq(100,000\Delta)^{2}$ we have $T=|S|\geq\frac{\sqrt{n}}{100}\geq\frac{100,000\Delta}{100}$. By Lemma 3.20, with probability at least $\frac{7}{10}$, the minimum will be compared against a value that is larger than $G^{-i}$. Thus, by law of total probability, it follows that in case of a good event, with probability $\frac{7}{10}$ the minimum will be compared to a value in the range $(G^{-i},G^{-i+1})$. However, as the good event happens with probability $\frac{9}{10}$, it follows that with probability at least $1-(1-\frac{7}{10})-(1-\frac{9}{10})=\frac{6}{10}$, the minimum will be compared against a value in the range $(G^{-i},G^{-i+1})$.

3.3.2 Lower bound for the fragile complexity of the minimum whp.

With Theorem 3.13 in Subsection 3.2, we show in particular that SampleMinimum guarantees that the fragile complexity of the minimum is at most $\mathcal{O}(\log\log n)$ with probability at least $1-1/n^{c}$ for any $c>1$. (By setting $t=2\log\log n$).

Here we show that this is optimal up to constant factors in the fragile complexity.

Theorem 3.25**.**

For any constant $\varepsilon>0$, there exists a value of $n_{0}$ such that the following holds for any randomized algorithm $\mathcal{A}$ and for any $n>n_{0}$: there exists an input of size $n$ such that with probability at least $n^{-\varepsilon}$, $\mathcal{A}$ performs $\geq\frac{1}{2}\log\log n$ comparisons with the minimum.

Proof 3.26**.**

We use (again) Yao’s principle and consider a fixed deterministic algorithm $\mathcal{A}$ working on the uniform input distribution, i.e., all input permutations have probability $1/n!$. Let $f=\frac{1}{2}\log\log n$ be the upper bound on the fragile complexity of the minimum. Let $k=2^{f}=\sqrt{\log n}$ and let $S$ be the set of the $k$ smallest input values. Let $\pi$ be a uniform permutation (the input) and $\pi(S)$ be the permutation of the elements of $S$ in $\pi$. Observe that $\pi(S)$ is a uniform permutation of the elements of $S$. We reveal the elements not in $S$ to $\mathcal{A}$. So, $\mathcal{A}$ only needs to find the minimum in $\pi(S)$. By Theorem 3.1 there is at least one “bad” permutation of $S$ which forces algorithm $\mathcal{A}$ to do $\log k=f$ comparisons on the smallest element. Observe $\log k!<\log k^{k}=k\log k=\sqrt{\log n}\frac{1}{2}\log\log n$. Observe that there exists a value of $n_{0}$ such that for $n>n_{0}$ the right hand side is upper bounded by $\varepsilon\log n$, so $k!\leq n^{\varepsilon}$, for $n>n_{0}$. Hence, the probability of a “bad” permutation is at least $1/k!>n^{-\varepsilon}$.

4 Selection and median

The $(n,t)$-selection problem asks to find the $t$-th smallest element among $n$ elements of the input. The simplest solution to the $(n,t)$-selection problem is to sort the input. Therefore, it can be solved in $\mathcal{O}(\log n)$ fragile complexity and $\mathcal{O}(n\log n)$ work by using the AKS sorting network [2]. For comparator networks, both of these bounds are optimal: the former is shown by Theorem 3.1 (and in fact it applies also to any algorithm) and the latter is shown in Section 4.2.

In contrast, in this section we show that comparison-based algorithms can do better: we can solve Selection deterministically in $\Theta(n)$ work and $\Theta(\log n)$ fragile complexity, thus, showing a separation between the two models. However, to do that, we resort to constructions that are based on expander graphs. Avoiding usage of the expander graphs or finding a simpler optimal deterministic solution is an interesting open problem (see Section 7). Moreover, in Subsection 4.3 we show that we can do even better by using randomization.

4.1 Deterministic selection

Theorem 4.1**.**

There is a deterministic algorithm for Selection which performs $\mathcal{O}(n)$ work and has $\mathcal{O}(\log n)$ fragile complexity.

Proof 4.2**.**

Below, we give an algorithm for the median problem. By simple padding of the input, median solves the $(n,t)$-selection problem for arbitrary $t\neq\frac{n}{2}$.

A central building block from the AKS sorting network is an $\varepsilon$-halver. An $\varepsilon$-halver approximately performs a partitioning of an array of size $n$ into the smallest half and the largest half of the elements. More precisely, for any $m\leq n/2$, at most $\varepsilon n$ of the $m$ smallest elements will end up in the right half of the array, and at most $\varepsilon n$ of the $m$ largest elements will end up in the left half of the array. Using expander graphs, a comparator network implementing an $\varepsilon$-halver in constant depth can be built [2, 4]. We use the corresponding comparison-based algorithm of constant fragile complexity.

We make the convention that when using $\varepsilon$-halvers, the larger elements placed at the right half and the smaller elements are placed at the left half. We first use an $\varepsilon$-halver on the input array $S$ of length $n$, dividing it into two subarrays of length $n/2$. Let’s call the right half $S_{1}$. As an $\varepsilon$-halver does an “approximate” partitioning, $S_{1}$ will contain $l$ of the smallest $n/2$ elements by mistake, however, it will contain $n/2-l$ of the $n/2$ largest with $l\leq\varepsilon n/2$. From this point forward, we apply $\varepsilon$-halvers but alternate between picking the right and then left half. In particular, we apply an $\varepsilon$-halver to $S_{i}$ (starting from $i=1$), and set $S_{i+1}$ to be the left half (resp. right half) of the resulting partition if $i$ is odd (resp. if $i$ is even). See Figure 2.

We stop the process after $k=2\lfloor\frac{\log\log n}{2}\rfloor$ steps; we choose an even $k$ to simplify the upcoming discussions. This results in a set $S_{k}$ of size $\Theta(n/\log n)$. We sort $S_{k}$ using an AKS-based sorting algorithm, which takes $\mathcal{O}(n)$ work and has fragile complexity $\mathcal{O}(\log n)$, and we then extract the middle $|S_{k}|/2$ of these sorted elements as the set $R_{P}$ (“right pivots”).

We claim the rank of every element in $R_{P}$ is between $(1+\alpha)\frac{n}{2}$ and $(2-\alpha)\frac{n}{2}$ for some absolute constant $0<\alpha<1$. To prove this claim, we use the properties of $\varepsilon$-halvers. Consider $S_{i}$: we partition $S_{i}$ into two sets, and select $S_{i+1}$ to be either the left or the right half, depending on the parity of $i$. Assume $S_{i+1}$ is selected to be the right half (similarly, left half). We mark an element of $S_{i+1}$ as a left mistake (similarly, a right mistake), if it is among the $|S_{i}|/2$ smaller (similarly, larger) elements of $S_{i}$. We say an element of $S_{i+1}$ is good.

Now assume $\varepsilon<1/64$. We can now use simple induction to show the following: If $S_{i}$ contains $t_{\ell}$ left mistakes and $t_{r}$ right mistakes, then the left mistakes are the $t_{\ell}$ smallest element of $S_{i}$ and the right mistakes are the $t_{r}$ largest elements in $S_{i}$ and furthermore, $S_{i}$ contains at most $2\varepsilon|S_{i}|$ left mistakes and $2\varepsilon|S_{i}|$ right mistakes.

These claims are obviously true for $S_{1}$ and $S_{2}$ thus assume the hold for $S_{i}$; we would like to show that they also hold for $S_{i+2}$. W.l.o.g, assume $S_{i+1}$ is selected to be the right half after partitioning $S_{i}$ using an $\varepsilon$-halver. Consider the sorted order of $S_{i}$ and in particular, the set $L$ containing $|S_{i}|/2$ largest elements in $S_{i}$. As $\varepsilon<1/64$, it follows that $2\varepsilon|S_{i}|<|S_{i}|/2$ and as a result, $L$ contains no left mistakes by our induction hypothesis since all the left mistakes are among the $|S_{i}|/2$ smallest elements of $|S_{i}|$. However, $L$ contains all the up to $2\varepsilon|S_{i}|$ right mistakes. By properties of an $\varepsilon$-halver, $S_{i+1}$ has at most $\varepsilon|S_{i}|$ elements that do not belong in $L$. Thus, $S_{i+1}$ contains at most $\varepsilon|S_{i}|$ left mistakes and at most $2\varepsilon|S_{i}|$ right mistakes. Crucially, notice that $S_{i+2}$ is obtained by using an $\varepsilon$-halver on $L$ and selecting the left half of the resulting partition. A similar argument now shows that $S_{i+2}$ has $\varepsilon|S_{i}|=2\varepsilon|S_{i+1}|$ left mistakes but $\varepsilon|S_{i+1}|$ right mistakes. This concludes the inductive proof of our claims. Observe that, as a corollary, at least $1-4/\varepsilon>1/2$ fraction of the elements in $S_{i}$ are good.

After $i$ steps, we have an array part $S_{i}$ of length $n_{i}=n/2^{i}$ with at most $2\varepsilon n_{i}$ left mistakes and at most $2\varepsilon n_{i}$ right mistakes. For a moment assume there are no mistakes in any of the partitioning steps done by $\varepsilon$-halvers. An easy inductive proof implies that in this case, the rank of the elements in $S_{i}$, for even $i$, are between $A_{i}=(1+\frac{4^{i-1}-1}{34^{i-1}})\frac{n}{2}$ and $B_{i}=(1+\frac{4^{i-1}+3}{34^{i-1}})\frac{n}{2}$. The claim is clearly true for $i=2$ and it can be verified for $i+2$: there are $\frac{n}{2}\frac{1}{4^{i-1}}$ elements between the aforementioned ranks and thus, the ranks of the elements in $S_{i+2}$ will between $A_{i}+\frac{n}{2}\frac{1}{4^{i}}$ and $A_{i}+2\frac{n}{2}\frac{1}{4^{i}}$ (partition the range between $A_{i}$ and $B_{i}$ into four equal chunks and pick the second chunk). Now observe that $A_{i}+\frac{n}{2}\frac{1}{4^{i}}=(1+\frac{4^{i-1}-1}{34^{i-1}}+\frac{1}{4^{i}})\frac{n}{2}=(1+\frac{4^{i}-1}{34^{i}})\frac{n}{2}$ and $A_{i}+2\frac{n}{2}\frac{1}{4^{i}}=(1+\frac{4^{i-1}-1}{34^{i-1}}+2\frac{1}{4^{i}})\frac{n}{2}=(1+\frac{4^{i}+3}{34^{i}})\frac{n}{2}$.

However, $\varepsilon$-halvers will likely make plenty of mistakes. Nonetheless, observe that every mistake made by an $\varepsilon$-halver can only change the rank of a good element $x$ in $S_{k}$ by one: each mistake either involves placing an element that is actually smaller than $x$ to the right of $x$ or an element that is larger than $x$ to the left of $x$. Furthermore, observe that the total number of elements marked as a mistake is bounded by a geometric series:

[TABLE]

This in turn implies that the rank of the good elements in $S_{k}$ is between

[TABLE]

and

[TABLE]

Remember that $S_{k}$ contains $\Theta(n/\log n)$ good elements. We might not know exactly which elements of $S_{k}$ are good but we know that the middle $|S_{k}|/2$ elements are certainly good. As discussed, we select these elements as our pivot set $R_{P}$. We now compare all elements $y$ of $S$ with some element $x$ from $R_{P}$. We evenly distribute the comparisons such that every element of $R_{P}$ gets compared against at most $\lceil n/|R_{P}|\rceil=O(\log n)$ elements. If $x\geq y$, we mark $y$ by $\mathcal{R}$. An element marked by $\mathcal{R}$ has rank in $S$ of at least $(1+1/8)n/2$ by Eq. 1, and thus it is guaranteed not to be the median. By Eq. 2, we mark at least $n/16$ elements by $\mathcal{R}$.

We then perform a symmetric process in the first half of $S$, leading to a set $\overline{S}_{k}$ of size $\Theta(n/\log n)$ which has a subset $L_{P}$ (for “left pivots”) of $\Theta(n/\log n)$ elements whose rank in $S$ are between $\frac{1}{8}\cdot\frac{n}{2}$ and $\frac{7}{8}\cdot\frac{n}{2}$. We compare all elements $y$ of $S$ with some element $x^{\prime}$ from $L_{P}$ and as before distribute the comparisons evenly among the elements of $L_{P}$. If $y<x^{\prime}$, we mark $y$ by $\mathcal{L}$. And as before, an element marked by $\mathcal{L}$ is smaller than the median and at least $n/16$ elements are marked by $\mathcal{L}$.

We can discard an element of mark $\mathcal{L}$ together with an element of mark $\mathcal{R}$ as doing so will not change the median among the remaining elements, as we are discarding an element larger than the median and an element smaller than the median. As a result, we can discard $n/8$ elements.

At first glance, it might feel like we are done. However, we cannot safely recurse on the remaining elements as the elements in $S_{k}$ and $\overline{S}_{k}$ have already incurred too many comparisons. This results in a slight complication but it can be averted as follows.

At the beginning we have an input $S$ of $n$ elements. Define $S^{(0)}=S$ and $n^{(0)}=n$ as the top level of our recursion. At depth $i$ of the recursion, we have a set $S^{(i)}$ containing $n^{(i)}$ elements. We then select sets $S^{(i)}_{k}$ and $\overline{S}^{(i)}_{k}$ (note that $k$ is also a function of $i$ but to reduce the clutter in the notation, we just use $k$) and discard $n^{(i)}/8$ elements of $S^{(i)}$ using the above mentioned procedure. The set $S^{(i+1)}$ is defined as the set containing the remaining elements, excluding the elements of the sets $S^{(i)}_{k}$ and $\overline{S}^{(i)}_{k}$; the elements of these sets are not pruned but they are put aside and we will handle them later.

We stop the recursion as soon as we reach a recursion depth $j$ with $n^{(j)}\leq n/\log n$. At this point, we simply union all the elements in the sets $S^{(i)}_{k}$ and $\overline{S}^{(i)}_{k}$, $1\leq i<j$ and $S^{(j)}$ into a final set $\mathcal{S}$, sort $\mathcal{S}$ and then report the median of $\mathcal{S}$. As discussed, pruning elements does not change the median and thus the reported median is correct. Note that since we always prune a fraction of the elements at each recursive step, we have $j=O(\log\log n)$.

We now analyze the fragile complexity. Invoking an $\varepsilon$-halver incurs $\mathcal{O}(1)$ comparisons on each element, so a full division process incurs $\mathcal{O}(\log\log n)$ comparisons on each element of $S^{(i)}$. Over $j=O(\log\log n)$ recursions, this adds up to $O((\log\log n)^{2})=O(\log n)$. Next, the elements in $S^{(i)}_{k}$ and $\overline{S}^{(i)}_{k}$ are sorted but they are not sent to the next recursion step so this is simply a one-time cost. These elements suffer an additional $\Theta(\log n)$ comparisons during the pruning phase (to be precise, a subset of them that are selected as “left pivot” or “right pivot” elements) but this cost is also only suffered once. Finally, the remaining elements participate in a final sorting round. Thus, each element participates in $O(\log n)$ comparisons in the worst-case.

Thus, it remains to analyze the work. Invoking an $\varepsilon$-halver incurs a linear number of comparisons. However, as we prune at least a fraction of the elements at each step, we have $n^{(i)}\leq n(\frac{7}{8})^{i}$. Thus, the total amount of work done by $\varepsilon$-halvers is linear. The same holds for the sorting of $S^{(i)}_{k}$ and $\overline{S}^{(i)}_{k}$ as their sizes is bounded by $O(n^{(i)}/\log n^{(i)})$ which forms a geometrically decreasing series. Finally, observe that $|\mathcal{S}|=O(n/\log n)$ since $S^{(j)}=O(n/\log n)$ and $\sum_{i=0}^{j}|S^{(i)}_{k}|+|\overline{S}^{(i)}_{k}|=O(n/\log n)$. his implies, we can sort $\mathcal{S}$ in $\mathcal{O}(n)$ work as well.

Corollary 4.3**.**

There is a deterministic algorithm for partition which performs $\mathcal{O}(n)$ work and has $\mathcal{O}(\log n)$ fragile complexity.

Proof 4.4**.**

At the end of the Selection algorithm, the set of elements smaller (larger) than the median is the union of the respective filtered sets (sets $\mathcal{L}$ and $\mathcal{R}$ in the proof in the full version of the paper [1]) and the first (last) half of the sorted set in the base case of the recursion. Again, simple padding generalizes this to $(n,t)$-partition for arbitrary $t\neq\frac{n}{2}$.

4.2 Deterministic selection via comparator networks

In this section, we discuss the $(n,t)$-selection problem in the setting of comparator networks. We present an upper and a matching lower bound on the size of a comparator network solving the $(n,t)$-selection problem. In the next section, we consider the problem in the setting of comparison-based algorithms and give an algorithm for selection with the same fragile complexity as in the case of comparator networks, but with total work that is asymptotically smaller. Combined, this shows a separation in power between the two models.

To begin, observe that the $(n,t)$-selection problem can be solved by sorting the input. Therefore, the $(n,t)$-selection problem can be solved using a comparator network of size $\mathcal{O}(n\log n)$ and depth $\mathcal{O}(\log n)$ by using the AKS sorting network [3]. Consequently, the $(n,t)$-selection problem can be solved with $\mathcal{O}(\log n)$ fragile complexity and $\mathcal{O}(n\log n)$ work.

Next, we show that the size of the $(n,t)$-selection network using the AKS network is asymptotically tight. Before we present the lower bound theorem, we need to introduce some notation and prove two auxiliary lemmas.

Given a set $X$, we say two elements $x_{i},x_{j}\in X$ are rank-neighboring if $|rank(x_{i})-rank(x_{j})|=1$. We say a permutation $\hat{\pi}(X)$ is rank-neighboring if an ordered sequence $X$ and $\hat{\pi}(X)$ differ in only two elements and these two elements are rank-neighboring. Observe that any permutation $\pi(X)$ is a composition of some number of rank-neighboring permutations.

We define the signature of an ordered sequence $X$ with respect to an integer $a$ to be a function $\sigma:\mathbb{Z}\times\mathbb{Z}^{n-1}\rightarrow\{0,1\}^{n-1}$, such that $\sigma(a,(x_{1},\dots,x_{n-1}))=(y_{1},\dots,y_{n-1})$ and for all $1\leq i\leq n-1$:

[TABLE]

Lemma 4.5**.**

For any totally ordered set $X$ of size $n$, any $(n,t)$-selection network $\mathcal{N}_{n,t}$, and for any rank-neighboring permutation $\hat{\pi}$: $\sigma(\mathcal{N}_{n,t}(X))=\sigma(\mathcal{N}_{n,t}(\hat{\pi}(X)))$.

Proof 4.6**.**

Consider the two inputs $x_{i}$ and $x_{j}$ in which $X$ and $\hat{\pi}(X)$ differ. During the computation the input values traverse the network until they reach the outputs. During the computation of the network $\mathcal{N}_{n,t}(X)$ element $x_{i}$ (resp., $x_{j}$) starts at the $i$-th (resp., $j$-th) input and reaches the $i^{\prime}$-th (resp., $j^{\prime}$-th) output. During the computation of the network $\mathcal{N}_{n,t}(\hat{\pi}(X))$, element $x_{i}$ (resp., $x_{j}$) starts at the $j$-th (resp., $i$-th) input. Let us determine which outputs they reach.

Consider the two paths $P_{i}$ and $P_{j}$ that $x_{i}$ and $x_{j}$, respectively, traverse during the computation of $\mathcal{N}_{n,t}(X)$. Since $\hat{\pi}$ is a rank-neighboring permutation, the outputs of every comparator $C$ are the same for $\mathcal{N}_{n,t}(X)$ and $\mathcal{N}_{n,t}(\hat{\pi}(X))$ except for the (set of) comparator(s) $C^{*}$, whose two inputs are $x_{i}$ and $x_{j}$. Thus, throughout the computation of $\mathcal{N}_{n,t}(\hat{\pi}(X))$, $x_{i}$ and $x_{j}$ only traverse the edges of the paths $P_{i}\cup P_{j}$, i.e., the outputs of $\mathcal{N}_{n,t}(\hat{\pi}(X))$ are the same as the outputs of $\mathcal{N}_{n,t}(X)$ everywhere except for, possibly, at the $i^{\prime}$-th and $j^{\prime}$-th output.

If $rank(x_{i})<t$ and $rank(x_{j})<t$, or $rank(x_{i})>t$ and $rank(x_{j})>t$, the signatures of these two outputs are the same. Consequently, $\sigma(\mathcal{N}_{n,t}(X))=\sigma(\mathcal{N}_{n,t}(\hat{\pi}(X)))$. Otherwise, without loss of generality, let $rank(x_{i})=t$ (the case of $rank(x_{j})=t$ is symmetric). Then $i^{\prime}=0$, and $\mathcal{N}_{n,t}(X)^{0}=\mathcal{N}_{n,t}(\hat{\pi}(X))^{0}=x_{i}$. Then, $\mathcal{N}_{n,t}(X)^{j^{\prime}}=\mathcal{N}_{n,t}(\hat{\pi}(X))^{j^{\prime}}=x_{j}$, and it follows that $\sigma(\mathcal{N}_{n,t}(X))=\sigma(\mathcal{N}_{n,t}(\hat{\pi}(X)))$.

Lemma 4.7**.**

An $(n,t)$-selection network can be turned into an $(n,t)$-partition network.

Proof 4.8**.**

Since every permutation $\pi(X)$ can be obtained from $X$ by a sequence of rank-neighboring permutations, it follows from Lemma 4.5 that $\sigma(\mathcal{N}_{n,t}(\pi(X)))=\sigma(\mathcal{N}_{n,t}(X))$, i.e., for every permutation of the inputs in the $(n,t)$-selection network, the same subset of outputs carry the values that are at most $t$. Thus, the $(n,t)$-partition network can be obtained from the $(n,t)$-selection network by reordering (re-wiring) the outputs such that the ones with signature [math] are the first $t$ outputs.

Theorem 4.9**.**

An $(n,t)$-selection network for any $t\leq n/2$ has size $\Omega((n-t)\log(t+1))$.

Proof 4.10**.**

Alekseev [5] showed the $\Omega((n-t)\log(t+1))$ lower bound for the size of an $(n,t)$-partition network, and, by Lemma 4.7, every $(n,t)$-selection network also solves the $(n,t)$-partition problem.

Corollary 4.11**.**

A comparator network that finds the median of $n$ elements has size $\Omega(n\log n)$.

4.3 Randomized selection

1:procedure RMedian($X=\{x_{1},\ldots,x_{n}\},k(\cdot),d(\cdot)$) $\triangleright$ Sampling phase

2:     Randomly sample $k$ elements from $X$, move them into an array $S$, sort $S$ with AKS

3:     Choose appropriate $b$ to distribute $S$ into buckets $L_{b},\ldots L_{1},C,R_{1},\ldots,R_{b}$ such that:

4:         $n_{0}=2\sqrt{k\log n}$, $n_{1}=3\sqrt{k\log n}$, $n_{i}=d\cdot n_{i-1}$

5:         $C=S[k/2{-}n_{0}:k/2{+}n_{0}]$ median candidates

6:         $L_{i}=S[k/2{-}n_{i}:k/2-n_{i-1}]$ buckets of elements presumed smaller than median

7:         $R_{i}=S[k/2{+}n_{i-1}:k/2{+}n_{i}]$ buckets of elements presumed larger than median $\triangleright$ Probing phase

8:     for $x_{i}\in X\setminus S$ in random order 

9:         for $j\in[b{-}1,\ldots,1]$ in order 

10:              $x_{A}\leftarrow$ arbitrary element in $L_{j}$ with fewest compares

11:              $c\leftarrow 1$ if $x_{A}$ is marked else $2$ $\triangleright$ Pivots added in probing (= weak) are marked

12:              if $x_{i}<x_{A}$ 

13:                  add $x_{i}$ as new pivot to $L_{j+c}$ if $j<b-c$ and mark it,

14:                       otherwise discard $x_{i}$ by inserting it into $L_{b}$

15:                  continue with next element $x_{i+1}$               

16:              $x_{B}\leftarrow$ arbitrary element in $R_{j}$ with fewest compares

17:              $c\leftarrow 1$ if $x_{B}$ is marked else $2$

18:              if $x_{i}>x_{B}$ 

19:                  add $x_{i}$ as new pivot to $R_{j+c}$ if $j<b-c$ and mark it,

20:                       otherwise discard $x_{i}$ by inserting it into $R_{b}$

21:                  continue with next element $x_{i+1}$                        $\triangleright$ By now it is established that $S[k/2-n_{1}]\leq x_{i}\leq S[k/2+n_{1}]$

22:         add $x_{i}$ as a median candidate to $C$      

23:     if $\max(\sum_{i}|L_{i}|,\sum_{i}|R_{i}|)>n/2$  $\triangleright$ Partitioning too imbalanced $\Rightarrow$ median not in $C$

24:         return DetMedian(X)      

25:     if $|C|<\log^{4}N$ where $N$ is the size of the initial input 

26:         sort $C$ with AKS and return median      

27:     $j=\sum_{i}\left(|L_{i}|-|R_{i}|\right)$

28:     if $j<0$ 

29:         add $|j|$ arbitrary elements from $\bigcup_{i}R_{i}$ to $C$

30:     else

31:         add $j$ arbitrary elements from $\bigcup_{i}L_{i}$ to $C$      

32:     return RMedian($C$, $k(\cdot)$, $d(\cdot)$)

We now present the details of an expected work-optimal selection algorithm with a trade-off between the expected fragile complexity $f_{\text{med}}(n)$ of the selected element and the maximum expected fragile complexity $f_{\text{rem}}(n)$ of the remaining elements. In particular, we obtain the following combinations:

Theorem 4.12**.**

Randomized selection is possible in expected linear work, while achieving expected fragile complexity of the median $\mathbb{E}\left[f_{\text{med}}(n)\right]=\mathcal{O}(\log\log n)$ and of the remaining elements $\mathbb{E}\left[f_{\text{rem}}(n)\right]=\mathcal{O}(\sqrt{n})$, or $\mathbb{E}\left[f_{\text{med}}(n)\right]=\mathcal{O}\left(\frac{\log n}{\log\log n}\right)$ and $\mathbb{E}\left[f_{\text{rem}}(n)\right]=\mathcal{O}(\log^{2}n)$.

Just like with the deterministic approach in Section 4.1 we restrict ourselves to the special case of median finding. The general $(n,t)$-selection problem can be solved by initially adding an appropriate number of distinct dummy elements. Note that comparisons of real elements with dummy elements do not contribute to the fragile complexity since we know that all dummy elements are either larger or smaller than all real elements depending on the value of $t$. Similarly, the comparison between dummy elements comes for free.

We present RMedian an expected work-optimal median selection algorithm with a trade-off between the expected fragile complexity $f_{\text{med}}(n)$ of the median element and the maximum expected fragile complexity $f_{\text{rem}}(n)$ of the remaining elements. By adjusting a parameter affecting the trade-off, we can vary $\left\langle\mathbb{E}\left[f_{\text{med}}(n)\right],\max\mathbb{E}\left[f_{\text{rem}}(n)\right]\right\rangle$ in the range between $\left\langle\mathcal{O}(\log\log n),\mathcal{O}(\sqrt{n})\right\rangle$ and $\left\langle\mathcal{O}(\log n/\log\log n),\mathcal{O}(\log^{2}n)\right\rangle$ (see Theorems 4.21 and 4.23).

RMedian (see pseudo code) takes a totally ordered set $X$ as input. It draws a set $S$ of $k(n)$ random samples, sorts them and subsequently uses the items in $S$ as pivots to identify a set $C\subset X$ of values around the median, such that an equal number of items smaller and greater than the median are excluded from $C$. Finally, it recurses on $C$ to select the median.

The recursion reaches the base case when the input is of size $\mathcal{O}(\operatorname{polylog}n)$, at which point it can be sorted to trivially expose the median. RMedian employs two sets $L_{1}$ and $R_{1}$ of $n_{1}=\mathcal{O}(\sqrt{k\log n})$ pivots almost surely below and above the median respectively. All candidates for $C$ are compared to one item in $L_{1}$ and $R_{1}$ each filtering elements that are either too small or too large. The sizes of $L_{1},R_{1}$ and $C$ are balanced to achieve fast pruning and low failure probability444RMedian is guaranteed to select the correct median. Failure results in an asymptotically insignificant increase of expected fragile complexity (see line 23 in the pseudocode). (see Lemmas 4.13 and 4.15).

To reduce the fragile complexity of elements in $L_{1}$ and $R_{1}$, most elements are prefiltered using a cascade of weaker classifiers $L_{i}$ and $R_{i}$ for $2\leq i\leq b$ geometrically growing in size by a factor of $d(n)$ when moving away from the center. Filtered elements that are classified into a bucket $L_{i}$ or $B_{i}$ with $i<b$ are used as new pivots and effectively limit the expected load per pivot. As the median is likely to travel through this cascade, the number of filter layers is a compromise between the fragile complexity $f_{\text{med}}$ of the median and $f_{\text{rem}}$ of the remaining elements.

We define $k(n)$ and $d(n)$ as functions since they depend on the problem size which changes for recursive calls. If $n$ is unambiguous from context, we denote them as $k$ and $d$ respectively and assume $k(n)=\Omega(n^{\varepsilon})$ for some $\varepsilon>0$.

Lemma 4.13**.**

Consider any recursion step and let $X$ be the set of $n$ elements passed as the subproblem. After all elements in $X$ are processed, the center partition $C$ contains the median $x_{m}\in X$ whp.

Proof 4.14**.**

The algorithm can fail to move the median into bucket $C$ only if the sample $S\subset X$ is highly skewed. More formally, we use a safety margin $n_{0}$ around the median of $S$ and observe that if there exists $x_{l},x_{r}\in S_{C}:=S[k/2{-}n_{0}:k/2+n_{0}]$ with $x_{l}<x_{m}<x_{r}$, the median $x_{m}$ is moved into $C$.

This fails in case too many small or large elements are sampled. In the following, we bound the probability of the former from above; the symmetric case of too many large elements follows analogously. Consider $k$ Bernoulli random variables $X_{i}$ indicating that the $i$-th sample $s_{i}<x_{m}$ lies below the median and apply Chernoff’s inequality $\mathbf{Pr}\left[\sum_{i}X_{i}>(1{+}\delta)\mu\right]\leq\exp(-\mu\delta^{2}/3)$ where $\mu=\mathbb{E}\left[\sum_{i}X_{i}\right]$ and $\delta<1$:

[TABLE]

Lemma 4.15**.**

Each recursion step of RMedian reduces the problem size from $n$ to $\mathcal{O}(\sqrt{n\log n})$ whp.

Proof 4.16**.**

The algorithm recurses on the center bucket $C$ which contains the initial sample of size $2n_{0}=\mathcal{O}(\sqrt{n\log n})$ and all elements that are not filtered out by $L_{1}$ and $R_{1}$. We pessimistically assume that each element added to $C$ compared to the weakest classifiers in these filters (i.e., the largest element in $R_{1}$ and the smallest in $L_{1}$).

We hence bound the rank in $X$ of the $R_{1}$’s largest pivot; due to symmetry $L_{1}$ follows analogously. Using a setup similar to the proof of Lemma 4.13, we define Bernoulli random variables indicating that the $i$-th sample $s_{i}$ is larger than the $\ell$-th largest element in $X$ where $\ell=n/2+3\sqrt{n\log(n)}$. Applying Chernoff’s inequality yields the claim.

Lemma 4.17**.**

The expected fragile complexity of the median is

[TABLE]

Proof 4.18**.**

Due to Lemma 4.15, a recursion step reduces the problem size from $n$ to $\mathcal{O}(\sqrt{n\log n})$ whp represented in the recursive summand. The remaining terms apply depending on whether the median is sampled or not: with $\mathbf{Pr}\left[x_{m}\not\in S\right]=1-k/n$ the median is not sampled and moved towards the center triggering a constant number of comparisons in each of the $\mathcal{O}(\log_{d}n)$ buckets. Otherwise if the median $x_{m}$ is sampled, it incurs $\mathcal{O}(\log k)$ comparisons while $S$ is sorted. By Lemma 4.13, the median is then assigned to $C$ whp and protected from further comparisons. According to Lemma 4.13, the complementary event of $x_{m}$ being misclassified has a vanishing contribution due to its small probability.

Lemma 4.19**.**

The expected fragile complexity of non-median elements is

[TABLE]

where $d(n)=\Omega(\log^{\varepsilon}n)$ for some $\varepsilon>0$ and $k(n)=\mathcal{O}(n/\log n)$.

Proof 4.20**.**

As the recursion is implemented analogously to Lemma 4.17, we discuss only the contribution of a single recursion step. Let $x\in X{\setminus}\{x_{m}\}$ be an arbitrary non-median element.

The element $x$ is either sampled and participates in $\mathcal{O}(\log k)$ comparisons. Otherwise it traverse the filter cascade and moves to $C$, $L_{i}$ or $R_{i}$ requiring $\mathcal{O}(\log_{d}n)$ comparisons.

If it becomes a median candidate (i.e. $x\in C$), $x$ has a fragile complexity as discussed in Lemma 4.17 which is asymptotically negligible here. Thus we only consider the case that $x$ is assigned to $L_{i}$ or $R_{i}$ and we assume $x\in R_{i}$ without loss of generality due to symmetry. If it becomes a member of the outer-most bucket $R_{b}$, it is effectively discarded. Otherwise, it can function as a new pivot element replenishing the bucket’s comparison budget. As RMedian always uses a bucket’s least-frequently compared element as pivot, it suffices to bound the expected number of comparisons until a new pivot arrives.

Observe that RMedian needs to find an element $y\in(R_{i-2}\cup R_{i-1})$ with $y<x$ in order to establish that $x\in R_{i}$. This is due to the fact that pivots can be placed near the unfavorable border of a bucket rendering them weak classifiers. We here pessimistically assume that $y\in R_{i-2}$ for simplicity’s sake. By construction the initial bucket sizes $n_{i}$ grow geometrically by a factor of $d$ as $i$ increases. Therefore, any item compared to bucket $R_{i}$ continues to the next bucket with probability at most $1/d$. Consequently, bucket $R_{i}$ with $i>2$ sustains expected $\mathcal{O}(d^{2})$ comparisons until a new pivot arrives.

This is not true for the two inner most buckets $R_{j}$ with $j\in\{1,2\}$ as they are not replenished. Bucket $R_{j}$ ultimately receives $\mathcal{O}(n\cdot\frac{n_{j}}{k})$ items whp, however it is expected to process $d$ times as many comparisons due to the possibly weak classifiers in the previous bucket $R_{j+1}$. Since bucket $R_{j}$ contains $n_{j}$ pivots in , each of it participates in $\mathcal{O}(nd/k)$ comparisons.

Theorem 4.21**.**

RMedian* achieves $\mathbb{E}\left[f_{\text{med}}(n)\right]=\mathcal{O}(\log\log n)$ and $\mathbb{E}\left[f_{\text{rem}}(n)\right]=\mathcal{O}(\sqrt{n})$.*

Proof 4.22**.**

Choose $k(n)=n^{\varepsilon}$, $d(n)=n^{\delta}$ with $\varepsilon=2/3$, $\delta=1/12$. Then Lemmas 4.17 and 4.19 yield:

[TABLE]

Theorem 4.23**.**

RMedian* achieves $\mathbb{E}\left[f_{\text{med}}(n)\right]=\mathcal{O}\left(\frac{\log n}{\log\log n}\right)$, $\mathbb{E}\left[f_{\text{rem}}(n)\right]=\mathcal{O}(\log^{2}n)$.*

Proof 4.24**.**

Choose $k(n)=\frac{n}{\log n}$, $d(n)=\log n$. Then Lemmas 4.17 and 4.19 yield:

[TABLE]

Theorem 4.25**.**

For $k=\mathcal{O}(n/\log n)$ and $d=\Omega(\log n)$, RMedian performs a total of $\mathcal{O}(n)$ comparisons in expectation, implying $w({n})=\mathcal{O}(n)$ expected work.

Proof 4.26**.**

We consider the first recursion step and analyze the total number of comparisons. RMedian sorts $k$ elements using AKS resulting in $\mathcal{O}(k\log k)=\mathcal{O}(n)$ comparisons. It then moves $\mathcal{O}(n)$ items through the filtering cascade consisting of buckets of geometrically decreasing size resulting of $\mathcal{O}(1)$ expected comparisons per item. Each bucket stores its pivots in a minimum priority queue with the number of comparisons endured by each pivot as keys. Even without exploitation of integer keys, retrieving and inserting keys is possible with $\mathcal{O}(\log n)$ comparisons each. Hence, we select a pivot and keep it for $d=\Omega(\log n)$ steps, resulting in amortized $\mathcal{O}(1)$ work per comparison. This does not affect $f_{\text{med}}$ and $f_{\text{rem}}$ asymptotically. Using Lemma 4.15, the total number of comparisons hence $g(n)=g(\sqrt{n\log n})+\mathcal{O}(n)=\mathcal{O}(n)$.

5 Sorting

Recall from Section 1 that the few existing sorting networks with depth $\mathcal{O}(\log n)$ are all based on expanders, while a number of $\mathcal{O}(\log^{2}n)$ depth networks have been developed based on binary merging. Here, we study the power of the mergesort paradigm with respect to fragile complexity. We first prove that any sorting algorithm based on binary merging must have a worst-case fragile complexity of $\Omega(\log^{2}n)$. This provides an explanation why all existing sorting networks based on merging have a depth no better than this. We also prove that the standard mergesort algorithm on random input has fragile complexity $\mathcal{O}(\log n)$ with high probability, thereby showing a separation between the deterministic and the randomized situation for binary mergesorts. Finally, we demonstrate that the standard mergesort algorithm has a worst-case fragile complexity of $\Theta(n)$, but that this can be improved to $\mathcal{O}(\log^{2}n)$ by changing the merging algorithm to use exponential search.

Lemma 5.1**.**

Merging of two sorted sequences $A$ and $B$ has fragile complexity at least $\lfloor\log_{2}|A|\rfloor+1$.

Proof 5.2**.**

A standard adversary argument: The adversary designates one element $x$ in $B$ to be the scapegoat and resolves in advance answers to comparisons between $A$ and $B_{1}=\{y\in B\mid y<x\}$ by $B_{1}<A$ and answers to comparisons between $A$ and $B_{2}=\{y\in B\mid x<y\}$ by $A<B_{2}$. There are still $|A|+1$ total orders on $A\cup B$ compatible with these choices, one for each position of $x$ in the sorted order of $A$. Only comparisons between $x$ and members of $A$ can make some of these total orders incompatible with answers given by the adversary. Since the adversary can always choose to answer such comparisons in a way which at most halves the number of compatible orders, at least $\lfloor\log_{2}|A|\rfloor+1$ comparisons involving $x$ have to take place before a single total order is known.

By standard MergeSort, we mean the algorithm which divides the $n$ input elements into two sets of sizes $\lceil n/2\rceil$ and $\lfloor n/2\rfloor$, recursively sorts these, and then merges the resulting two sorted sequences into one. The merge algorithm is not restricted, unless we specify it explicitly (which we only do for the upper bound, not the lower bound).

Lemma 5.3**.**

Standard MergeSort has fragile complexity $\Omega(\log^{2}n)$.

Proof 5.4**.**

In MergeSort, when merging two sorted sequences $A$ and $B$, no comparisons between elements of $A$ and $B$ have taken place before the merge. Also, the sorted order of $A\cup B$ has to be decided by the algorithm after the merge. We can therefore run the adversary argument from the proof of Lemma 5.1 in all nodes of the mergetree of MergeSort. If the adversary reuses scapegoat elements in a bottom-up fashion—that is, as scapegoat for a merge of $A$ and $B$ chooses one of the two scapegoats from the two merges producing $A$ and $B$—then the scapegoat at the root of the mergetree has participated in

[TABLE]

comparisons, by Lemma 5.1 and the fact that a node at height $i$ in the mergetree of standard MergeSort operates on sequences of length $\Theta(2^{i})$.

We now show that making unbalanced merges cannot improve the fragile complexity of binary MergeSort.

Theorem 5.5**.**

Any binary mergesort has fragile complexity $\Omega(\log^{2}n)$.

Proof 5.6**.**

The adversary is the same as in the proof of Lemma 5.3, except that as scapegoat element for a merge of $A$ and $B$ it always chooses the scapegoat from the larger of $A$ and $B$. We claim that for this adversary, there is a constant $c>0$ such that for any node $v$ in the mergetree, its scapegoat element has participated in at least $c\log^{2}n$ comparisons in the subtree of $v$, where $n$ is the number of elements merged by $v$. This implies the theorem.

We prove the claim by induction on $n$. The base case is $n=\mathcal{O}(1)$, where the claim is true for small enough $c$, as the scapegoat by Lemma 5.1 will have participated in at least one comparison. For the induction step, assume $v$ merges two sequences of sizes $n_{1}$ and $n_{2}$, with $n_{1}\geq n_{2}$. By the base case, we can assume $n_{1}\geq 3$. Using Lemma 5.1, we would like to prove for the induction step

[TABLE]

This will follow if we can prove that

[TABLE]

The function $f(x)=\log^{2}x$ has first derivative $2(\log x)/x$ and second derivative $2(1-\log x)/x^{2}$, which is negative for $x>e=2.71\dots$. Hence, $f(x)$ is concave for $x>e$, which means that first order Taylor expansion (alias the tangent) lies above $f$, i.e., $f(x_{0})+f^{\prime}(x_{0})(x-x_{0})\geq f(x)$ for $x_{0},x>e$. Using $x_{0}=n_{1}$ and $x=n_{1}+n_{2}$ and substituting the first order Taylor expansion into the right side of (5), we see that (5) will follow if we can prove

[TABLE]

which is equivalent to

[TABLE]

Since $n_{1}\geq n_{2}$ and $(\log x)/x$ is decreasing for $x\geq e$, we see that (6) is true for $n_{2}\geq 3$ and $c$ small enough. Since $\log(3)/3=0.366\dots$ and $\log{2}/2=0.346\dots$, it is also true for $n_{2}=2$ and $c$ small enough. For the final case of $n_{2}=1$, the original inequality (4) reduces to

[TABLE]

Here we can again use concavity and first order Taylor approximation with $x_{0}=n_{1}$ and $x=n_{1}+1$ to argue that (7) follows from

[TABLE]

which is true for $c$ small enough, as $n_{1}\geq 3$ and $(\log x)/x$ is decreasing for $x\geq e$.

5.1 Upper Bound for MergeSort with Linear Merging

By linear merging, we mean the classic sequential merge algorithm that takes two input sequence and iteratively moves the the minimum of both to the output.

Observation 1**.**

Consider two sorted sequences $A=(a_{1},\ldots,a_{n})$ and $B=(b_{1},\ldots,b_{n})$. In linear merging, the fragile complexity of element $a_{i}$ is at most $\ell+1$ where $\ell$ is the largest number of elements from $B$ that are placed directly in front of $a_{i}$ (i.e. $b_{j}<\ldots<b_{j+\ell-1}<a_{i}$).

Theorem 5.7**.**

Standard MergeSort with linear merging has a worst-case fragile complexity of $\Theta(n)$.

Proof 5.8**.**

Lower bound $f(n)=\Omega(n)$: linear merging requires $\mathcal{O}(k)$ comparisons to output a sequence of length $k$. In standard MergeSort, each element takes part in $\mathcal{O}(\log n)$ merges of geometrically decreasing sizes $n/2^{i}$ (from root), resulting in $\mathcal{O}(n)$ comparisons.

Upper bound $f(n)=\mathcal{O}(n)$: consider the input sequence $(n,1,2,\ldots,n{-}1)$ where $n=2^{k}$. Then every node on the the left-most path of the mergetree contains element $n$. In each merging step, we receive $A=(1,\ldots,\ell-1,n)$ from the left child, $B=(\ell,\ldots,2\ell{-}1)$ from the right, and produce

[TABLE]

Hence, the whole sequence $B$ is placed directly in front of element $n$, resulting in $\Theta(\ell)$ comparisons with this element according to Observation 1. Then, the sum of the geometrically increasing sequence length yields the claim.

Lemma 5.9**.**

Let $X=\{x_{1},\ldots,x_{2k}\}$ be a finite set of distinct elements, and consider a random bipartition $X_{L},X_{R}\subset X$ with $|X_{L}|=|X_{R}|=k$ and $X_{L}\cap X_{R}=\varnothing$, such that $\mathbf{Pr}\left[x_{i}\in X_{L}\right]=1/2$. Consider an arbitrary ordered set $Y=\{y_{1},\ldots,y_{m}\}\subset X$ with $m\leq k$. Then $\mathbf{Pr}\left[Y\subseteq X_{L}\lor Y\subseteq X_{R}\right]<2^{1-m}$.

Proof 5.10**.**

[TABLE]

Theorem 5.11**.**

Standard MergeSort with linear merging on a randomized input permutation has a fragile complexity of $\mathcal{O}(\log n)$ with high probability.

Proof 5.12**.**

Let $Y=(y_{1},\ldots,y_{n})$ be the input-sequence, $\pi^{-1}$ be the permutation that sorts $Y$ and $X=(x_{1},\ldots,x_{n})$ with $x_{i}=y_{\pi^{-1}(i)}$ be the sorted sequence. Wlog we assume that all elements are unique555If this is not the case, use input sequence $Y^{\prime}=((y_{1},1),\ldots,(y_{n},n))$ and lexicographical compares., that any input permutation $\pi$ is equally likely666If not shuffle it before sorting in linear time and no fragile comparisons., and that $n$ is a power of two.

Merging in one layer*. Consider any merging-step in the mergetree. Since both input sequences are sorted, the only information still observable from the initial permutation is the bi-partitioning of elements into the two subproblems. Given $\pi$, we can uniquely retrace the mergetree (and vice-versa): we identify each node in the recursion tree with the set of elements it considers. Then, any node with elements $X_{P}=\{y_{\ell},\ldots,y_{\ell+2k-1}\}$ has children*

[TABLE]

Hence, locally our input permutation corresponds to an stochastic experiment in which we randomly draw exactly half of the parent’s elements for the left child, while the remainder goes to right.

This is exactly the situation in Lemma 5.9. Let $N_{i}$ be a random variable denoting the number of comparisons of element $y_{i}$ in the merging step. Then, from Observation 1 and Lemma 5.9 it follows that $\mathbf{Pr}\left[N_{i}=m{+}1\right]\leq 2^{-m}$. Therefore $N_{i}$ is stochastically dominated by $N_{i}\preceq 1{+}Y_{i}$ where $Y_{i}$ is a geometric random variable with success probability $p=1/2$.

Merging in all layers*. Let $N_{j,i}$ be the number of times element $y_{i}$ is compared in the $j$-th recursion layer and define $Y_{j,i}$ analogously. Due to the recursive partitioning argument, $N_{j,i}$ and $Y_{j,i}$ are iid in $j$. Let $N^{T}_{i}$ be the total number of comparisons of element $i$, i.e. $N^{T}_{i}\preceq\log_{2}n+\sum_{j=1}^{\log_{2}n}Y_{j,i}$. Then a tail bound on the sum of geometric variables (Theorem 2.1 in [14]) yields:*

[TABLE]

where we set $\lambda\approx 3.69$ in the last step solving $\lambda{-}\log\lambda=2\log 2$. Thus, we bound the probability $\mathbf{Pr}\left[N^{T}_{i}\geq(1{+}2\lambda)\log_{2}n\right]\leq n^{-2}$.

Fragile complexity*. It remains to show that with high probability no element exceeds the claimed fragile complexity. We use a union bound on $N^{T}_{i}$ for all $i$:*

[TABLE]

5.2 Upper Bound for MergeSort with Exponential Merging

We define exponential merging of sequences $A=(a_{1},\ldots,a_{n})$ and $B=(b_{1},\ldots,b_{m})$ as follows: if either $A$ or $B$ are empty, output the other one and stop. Otherwise, assume without loss of generality that $m$ is a power of two and that there exists an $b_{i}\in Y$ with $a_{1}<b_{i}$, if not append sufficiently many virtual elements $b_{\top}$ to $B$ with $a_{1}<b_{\top}$. Use an exponential search on $B$ starting in $b_{1}$ to find all elements $b_{1}<\ldots<b_{\ell}<a_{1}$ smaller than $a_{1}$. As illustrated in Fig. 3, the exponential search consists of a doubling phase which finds the smallest $k$ with $a_{1}<b_{2^{k}}$. Since the doubling phase may overshoot $b_{\ell}$, a binary search between $b_{2^{k-1}}$ and $y_{b^{k}}$ follows. Output $b_{1},\ldots,b_{\ell},a_{1}$ and recurse on $A^{\prime}=[b_{\ell+1},\ldots,b_{m}]$ and $B^{\prime}=[a_{2},\ldots,a_{n}]$ which swaps the roles of $A$ and $B$.

Theorem 5.13**.**

Exponential merging of two sequences $A=(a_{1},\ldots,a_{n})$ and $B=(b_{1},\ldots,b_{n})$ has a worst-case fragile complexity of $\mathcal{O}(\log{n})$.

Proof 5.14**.**

Without loss of generality let $n$ be a power of two and consider a single exponential search finding the smallest $k$ with $a_{1}<b_{2^{k}}$. The element $a_{1}$ is compared to all $\{b_{2^{i}}\,|\,1\leq i\leq k\}$ during the doubling phase. We use an accounting argument to bound the fragile complexity. Element $a_{1}$ takes part in every comparison and is charged with $k=\mathcal{O}(\log n)$. It is then charged $\mathcal{O}(\log n)$ comparisons during the binary search between $b_{2^{k-1}}$ and $b_{2^{k}}$. It is then moved to the output and not considered again.

The search also potentially interacts with the $2^{k}$ elements $b_{1},\ldots,b_{2^{k}}$ by either comparing them during the doubling phase, during the binary search or by skipping over them. We pessimistically charge each of these elements with one comparison. It then remains to show that no element takes part in more than $\mathcal{O}(\log n)$ exponential searches.

Observe that all elements $b_{1},\ldots,b_{2^{k-1}}$ are moved to the output and do not take part in any more comparisons. In the worst-case, the binary search proves that element $b_{2^{k-1}+1}$ and its successors are larger than $a_{1}$. Hence at most half of the elements covered by the exponential search are available for further comparisons. To maximize the charge, we recursively setup exponential search whose doubling phases ends in $b_{2^{l}}$ yielding a recursion depth of $\mathcal{O}(\log n)$.777If the following searches were shorter they would artificially limit the recursion depth. If they were longer, too many elements are removed from consideration as only the binary search range can be charged again.

Corollary 5.15**.**

Applying Theorem 5.13 to standard MergeSort with exponential merging yields a fragile complexity of $\mathcal{O}(\log^{2}n)$ in the worst-case.

6 Constructing Binary Heaps

Theorem 6.1**.**

The fragile complexity of the standard binary heap construction algorithm of Floyd [11] is $\mathcal{O}(\log n)$.

Proof 6.2**.**

Consider first an element sifting down along a path in the tree: as the binary tree being heapified has height $\mathcal{O}(\log(n))$ and the element moving down is compared to one child per step, the cost to this element before it stops moving is $\mathcal{O}(\log(n))$. Consider now what may happen to an element $x$ in the tree as another element $y$ is sifting down: $x$ is only hit if $y$ is swapped with the parent of $x$ which implies that $y$ was an ancestor of $x$. As the height of the tree is $\mathcal{O}(\log(n))$, at most $\mathcal{O}(\log(n))$ elements reside on the path above $x$. Note that the $x$ may be moved up once as $y$ passes by it; this only lowers the number of elements above $x$. In total, any element in the heap is hit at most $\mathcal{O}(\log(n))$ times during heapify.

We note that this fragile complexity is optimal by Theorem 3.1, since Heap Construction is stronger than Minimum. Brodal and Pinotti [7] showed how to construct a binary heap using a comparator network in $\Theta(n\log\log n)$ size and $\mathcal{O}(\log n)$ depth. They also proved a matching lower bound on the size of the comparator network for this problem. This, together with Observation 6.1 and the fact that Floyd’s algorithm has work $\mathcal{O}(n)$, gives a separation between work of fragility-optimal comparison-based algorithms and size of depth-optimal comparator networks for Heap Construction.

7 Conclusions

In this paper we introduced the notion of fragile complexity of comparison-based algorithms and we argued that the concept is well-motivated because of connections both to real world situations (e.g., sporting events), as well as other fundamental theoretical concepts (e.g., sorting networks). We studied the fragile complexity of some of the fundamental problems and revealed interesting behavior such as the large gap between the performance of deterministic and randomized algorithms for finding the minimum. We believe there are still plenty of interesting and fundamental problems left open. Below, we briefly review a few of them.

• •

The area of comparison-based algorithms is much larger than what we have studied. In particular, it would be interesting to study “geometric orthogonal problems” such as finding the maxima of a set of points, detecting intersections between vertical and horizontal line segments, $kd$-trees, axis-aligned point location and so on. All of these problems can be solved using algorithms that simply compare the coordinates of points.

• •

Is it possible to avoid using expander graphs to obtain simple deterministic algorithms to find the median or to sort?

• •

Is it possible to obtain a randomized algorithm that finds the median where the median suffers $O(1)$ comparisons on average? Or alternatively, is it possible to prove a lower bound? If one cannot show a $\omega(1)$ lower bound for the fragile complexity of the median, can we show it for some other similar problem?