Stochastic and Worst-Case Generalized Sorting Revisited

In the generalized sorting problem, we wish to sort the vertices of a graph, but only certain pairs of vertices are permitted to be compared. The input to the problem is a graph $G=(V,E)$, where the vertices represent the elements to be sorted, and the edges indicate the pairs of vertices that can be compared; we will use $x_{1},x_{2},\ldots,x_{n}$ to denote the true ordering of the vertices $V$, and we say that $x_{i}\prec x_{j}$ if $i<j$. The goal is to sort the vertices (i.e., discover the true ordering) with as few comparisons as possible. In this setting, comparisons are also referred to as edge queries, meaning that the goal is to achieve the minimum possible query complexity.

In order for an input to the generalized sorting problem to be valid, it is required that the true ordering $x_{1}\prec x_{2}\prec\cdots\prec x_{n}$ of the vertices $V$ appears as a Hamiltonian path in $G$. This ensures that, should an algorithm query every edge, the algorithm will be able to deduce the true order of the vertices.

A classic special case of the generalized sorting problem is the nuts-and-bolts problem, which considers the case where $G$ is a complete bipartite graph. The vertices on one side of the graph represent “nuts” and vertices on the other side of the graph represent “bolts”. The goal is to compare nuts to bolts in order to match up each nut with its correspondingly sized bolt. Nuts cannot be compared to other nuts and bolts cannot be compared to other bolts, which is why the graph has a complete bipartite structure. The problem was first introduced in 1994 by Alon et al. [1], who gave a deterministic $O(n\lg^{4}n)$-time algorithm. Subsequent work [2, 13, 6] improved the running time to $O(n\lg n)$, which is asymptotically optimal.

The first nontrivial bounds for the full generalized sorting problem were given by Huang et al. [11], who studied two versions of the problem:

• •

  Worst-case generalized sorting: In the worst-case version of the problem, $G$ is permitted to have an arbitrary structure. A priori, it is unclear whether it is even possible to achieve $o(n^{2})$ comparisons in this setting. The paper [11] showed that this is always possible, with a randomized algorithm achieving query complexity $\tilde{O}(n^{1.5})$ for any graph $G$, with high probability.

• •

  Stochastic generalized sorting: In the stochastic version of the problem, every vertex pair $(u,v)$ (that is not part of the Hamiltonian path for the true order) is included independently and randomly with some probability $p$. The paper [11] gave a randomized algorithm with $\tilde{O}(\min\{n/p^{2},n^{3/2}\sqrt{p}\})$ query complexity, which evaluates to $\tilde{O}(n^{1.4})$ for the worst-case choice of $p$.

Although there have been several subsequent papers on the topic [4, 14, 5] (which we will discuss further shortly), these upper bounds of $\tilde{O}(n^{1.5})$ and $\tilde{O}(n^{1.4})$ have remained the state of the art for the worst-case and stochastic generalized sorting problems, respectively. Moreover, no nontrivial lower bounds are known. Thus it is an open question how these problems compare to standard comparison-based sorting.

The main result of this paper is an algorithm for stochastic generalized sorting with query complexity $O(n\lg(pn))$. This means that, in the worst case, the query complexity of stochastic generalized sorting is asymptotically the same as that of classical sorting. Perhaps even more remarkably, when $p$ is small, stochastic generalized sorting is actually easier than its classical counterpart; for example, when $p=\frac{\operatorname{polylog}(n)}{n}$, the query complexity becomes $O(n\lg\lg n)$.

When $p=(\lg n+\omega(1))/n$, which is the parameter regime in which the Erdös-Renyi random graph $G(n,p)$ contains at least one Hamiltonian cycle with overwhelming probability, we prove a matching lower bound of $\Omega(n\lg(pn))$ for the query complexity of any stochastic-generalized-sorting algorithm. Thus our algorithm is optimal.

Given that the optimal running time for stochastic generalized sorting is faster for sparser graphs, a natural question is whether the running time for worst-case generalized sorting can also be improved in the sparse case. It is known that in the very dense case, where there are $\binom{n}{2}-q$ edges, there is an algorithm with query complexity $(n+q)\lg n$ [4]. However, in the case where there are $m\ll\binom{n}{2}$ edges, the state-of-the-art remains the $\min(m,\tilde{O}(n^{1.5}))$ bound of [11], where one can always get an $O(m)$-query bound simply by querying all edges.

Our second result is a new algorithm for worst-case generalized sorting with query complexity $\tilde{O}(\sqrt{nm})$, where $n$ is the number of vertices and $m$ is the number of edges. The algorithm is obtained by combining the convex-geometric approach of [11] with the predictions-based approach of [4].

Interestingly, if we instantiate $m=p\binom{n}{2}$ for some $p\in(0,1]$, then the running time becomes $\tilde{O}(n^{1.5}\sqrt{p})$, which is precisely what the previous state of the art was was for the stochastic generalized sorting problem (in the sparse case of $p<1/n^{1/5}$) [11].

The original bounds by Huang et al.[11] for both the worst-case and the stochastic generalized sorting problems remained unimproved until now. The difficulty of these problems has led researchers to consider alternative formulations that are more tractable. Banerjee and Richards [4] considered the worst-case generalized sorting problem in the setting where $G$ is very dense, containing $\binom{n}{2}-q$ edges for some parameter $q$, and gave an algorithm that performs $O((q+n)\lg n)$ comparisons; whether this is optimal remains open, and the best known lower bound is $\Omega(q+n\lg n)$ [5]. Banerjee and Richards [4] also gave on alternative algorithm for the stochastic generalized sorting problem, achieving $\tilde{O}(\min\{n^{3/2},pn^{2}\})$ comparisons, but this bound is never better than that of [11] for any $p$. Work by Lu et al. [14] considered a variation on the worst-case generalized sorting problem in which we are also given predicted outcomes for all possible comparisons, and all but $w$ of the predictions are guaranteed to be true. The authors [14] show that, in this case, it is possible to sort with only $O(n\lg n+w)$ comparisons.

The generalized sorting problem is also closely related to the problem of sorting with comparison costs. In this problem, we are given as input $\binom{n}{2}$ nonnegative costs $\{c_{u,v}\mid u,v\in V\}$, where $V$ is the set of elements that must be sorted and $c_{u,v}$ is the cost of comparing $u$ to $v$. The goal is to determine the true order $x_{1}\prec x_{2}\prec\cdots\prec x_{n}$ of $V$ at a cost that is as close as possible to the optimal cost

$$\text{OPT}=c_{x_{1},x_{2}}+c_{x_{2},x_{3}}+\cdots+c_{x_{n-1},x_{n}}.$$

If all comparisons have equal costs, the problem reduces to traditional sorting and the optimal competitive ratio is $O(\lg n)$. On the opposite side of the spectrum, if the costs are allowed to be arbitrary, then the best achievable competitive ratio is known to be $\Omega(n)$ [9]. Nonetheless, there are many specific families of cost functions for which better bounds are achievable. Gupta and Kumar [9] consider the setting in which each of the elements $v\in V$ represents a database entry of some size $s_{v}$, and the costs $c_{u,v}$ are a function of the sizes $s_{v}$ and $s_{u}$; two especially natural cases are when $c_{u,v}=s_{v}+s_{u}$ or $c_{u,v}=s_{u}s_{v}$, and in both cases, a competitive ratio of $O(\lg n)$ can be achieved [9].¹¹1 The authors [9] also describe an algorithm for arbitrary monotone cost functions, but the analysis of the algorithm has been observed by subsequent work to be incorrect in certain cases [12]. Several other families of cost functions have also been considered. Gupta and Kumar [10] consider the setting in which the costs induce a metric space over the elements $V$, and give a $O(\lg^{2}n)$-competitive algorithm. In another direction, Angelov et al. [3] consider costs that are drawn independently and uniformly from certain probability distributions (namely, the uniform distribution on $[0,1]$, and the Bernoulli distribution with $\Pr[X=1]=p$), and give a $O(\lg n)$-competitive algorithm in each case. The unifying theme across these works is that, by focusing on specific families of cost functions, polylogarithmic competitive ratios can be achieved.

The generalized sorting problem can also be interpreted in this cost-based framework, with queryable edges having cost 1 and un-queryable edges having cost $\infty$. The presence of very large (infinite) costs significantly changes the nature of the problem, however. The fact that some edges simply cannot be queried makes it easy for an algorithm to get “stuck”, unable to query the edge that it needs to query in order to continue. Whereas sorting with well-behaved (and bounded) cost functions is, at this point, a relatively well understood problem, the problem of sorting with infinite costs on some edges (i.e., generalized sorting) has remained much more open.

Suppose that we are given an instance $G=(V,E)$ of the stochastic generalized sorting problem, where $|V|=n$, and where $p$ is the edge sampling probability. Let $x_{1},x_{2},\ldots,x_{n}$ denote the true order of the vertices (and recall that we use $x_{i}\prec x_{j}$ to denote that $i<j$). Note that the edges $(x_{i},x_{i+1})$ are all included deterministically in $E$, and that each other edge is included independently and randomly with probability $p$. Further note that the edges in $E$ are undirected, so the edge $(u,v)$ is the same as the edge $(v,u)$.

The algorithm starts by constructing sets of edges $E_{1},E_{2},\ldots,E_{q}$, where $q=\lg(np)$ and where each $E_{i}$ consists of roughly a $1/2^{i}$ fraction of all the edges $E$. These sets of edges are constructed once at the beginning of the algorithm, and are never modified.

The algorithm then places the vertices into levels $L_{1}\subseteq L_{2}\subseteq\cdots\subseteq L_{q+c}$, where $c$ is some large positive constant. The top levels $L_{q+1},\ldots,L_{q+c}$ automatically contain all of the vertices. To construct the lower levels, we use the following promotion rule to determine whether a given vertex $v$ in a level $L_{i+1}$ should also be placed into level $L_{i}$: if there is some vertex $u\prec v$ such that $u\in L_{i+c}$ and $(u,v)\in E_{i}$, then we consider $v$ to be blocked by $u$; otherwise, if there is no such $u$, then $v$ gets promoted to level $L_{i}$.

As we shall describe shortly, our algorithm discovers the true order of the vertices $x_{1},x_{2},\ldots$ one vertex at a time. At any given moment, we will use $x_{\ell}$ to denote the most recently discovered vertex in the true order, and we will say that each remaining vertex $x_{i}$, $i>\ell$, has rank $r(x_{i})=i-\ell$.

Before we describe how to discover the true order of the vertices, let us first describe how the levels are updated as we go. Intuitively, the goal of this construction is to make it so that, at any given moment, each level $L_{i}$ has size roughly $s_{i}=2^{i}/p$, and so that the majority of the elements in $L_{i}$ have rank $O(s_{i})$. We refer to $s_{i}=2^{i}/p$ as the target size for level $L_{i}$.

Whenever we discover a new vertex $x_{\ell}$ (i.e., we discern that some vertex $q$ is the $\ell$-th vertex in the true order), we perform incremental updates to the levels as follows: we remove $x_{\ell}$ from all of the levels, and then for each vertex $v$ that was previously blocked from promotion by $x_{\ell}$, we apply the promotion rule as many times as necessary to determine what new level $v$ should be promoted to. Note that, when we apply the promotion rule to a vertex $v$ in a level $L_{i+1}$, we apply it based on the current set $L_{i+c}$, and even if the set $L_{i+c}$ changes in the future, we do not consequently “unpromote” the vertex.

In addition to the incremental updates, we also periodically rebuild entire levels from scratch. In particular, we rebuild the levels $L_{i},L_{i-1},\ldots,L_{1}$ whenever the number $\ell$ of vertices that we have discovered is a multiple of $s_{i}/32$. (Recall that $s_{i}=2^{i}/p$ is our target size for each level $L_{i}$.) To rebuild a level $L_{i}$, we take the vertices currently in $L_{i+1}$ and apply the promotion rule to each of them (based on the current values of the sets $L_{i+1}$ and $L_{i+c}$).

We remark that, whereas incremental updates can only promote vertices (and cannot unpromote them), the process of rebuilding the levels $L_{i},L_{i-1},\ldots,L_{1}$, one after another, can end up moving vertices in both directions. Moreover, there are interesting chains of cause and effect. For example, if a vertex $v$ gets unpromoted from level $L_{i}$ (so now it no longer appears in $L_{i}$), then that may cause some vertex $v^{\prime}\in L_{i-c+1}$ to no longer be blocked, meaning that $v^{\prime}$ now gets promoted to $L_{i-c}$; the addition of $v^{\prime}$ to $L_{i-c}$ may block some $v^{\prime\prime}\in L_{i-2c+1}$ from being able to reside in level $L_{i-2c}$, causing $v^{\prime\prime}$ to get unpromoted from $L_{i-2c}$, etc.

Having described how we maintain the levels $L_{1},L_{2},\ldots$, let us describe how we use the levels to discover the next vertex $x_{\ell+1}$. We first construct a candidate set $C$ consisting of the vertices $v\in L_{1}$ such that $(x_{\ell},v)\in E$. Then, for each $v\in C$, we determine whether $v=x_{\ell+1}$ by going through the levels $L_{i}$ in order of $i=1,2,\ldots,q+c$, and querying all of the edges between $v$ and the level $L_{i}$; we can remove $v$ from the candidate set $C$ if we ever find an edge $(u,v)$, where $u$ is in some $L_{i}$ and $u\prec v$. In particular, all vertices $u\prec x_{\ell+1}$ have already been discovered and removed from the levels $L_{i}$, so the existence of such a vertex $u\prec v$ implies that $v\neq x_{\ell+1}$.

In the worst case, the process for eliminating a vertex $v$ from the candidate set $C$ might have to look at all of the edges incident to $v$. One of the remarkable features of our algorithm is that, because of how the levels are structured, the expected number of queries needed to identify $x_{\ell+1}$ ends up being only $O(\lg(pn))$.

In the rest of the section, we discuss how to bound the expected number of edge queries made by the algorithm. For now, we will ignore issues surrounding whether events are independent, and we will think of events that are “morally independent” as being fully independent. One of the main challenges in the full analysis is to define the events being analyzed in such a way that these interdependence issues can be overcome.

Our analysis proceeds in three parts. First we analyze for each vertex $v$ and each level $L_{i}$ the probability that $v\in L_{i}$ at any given moment. Next, we use this to bound the total number of queries spent maintaining the levels $L_{i}$. Finally, we bound the number of queries spent eliminating candidates from candidate sets (i.e., actually identifying each $x_{\ell}$).

Consider a vertex $v$ with rank $r(v)\approx s_{j}$. We will argue that $v$ is likely to appear in the levels $L_{j},L_{j+1},\ldots$ and is unlikely to appear in the levels $L_{j-c},L_{j-c-1},\ldots,L_{1}$.

Begin by considering $\Pr[v\in L_{j+i}]$ for some $i\geq 0$. If $v\not\in L_{j+i}$, then there must be some vertex $u$ with rank $1\leq r(u)\leq r(v)\approx s_{j}$ such that the edge $(u,v)$ is in one of $E_{j+i},E_{j+i+1},\ldots$. However, there are only $O(s_{j})=O(2^{j}/p)$ total vertices $u$ with ranks $1\leq r(u)\leq r(v)$, and only a $p$-fraction of them have an edge to $v$. Moreover, only a $O(1/2^{i+j})$ fraction of those edges are expected to appear in one of $E_{j+i},E_{j+i+1},\ldots$. So the probability of any such edge appearing is that most

$$O((2^{j}/p)\cdot p/2^{i+j})=O(1/2^{i}).$$

In other words, if $v$ has rank $r(v)\approx s_{j}$, then

$$\Pr[v\in L_{j+i}]=1-O(1/2^{i})$$

(1)

for each level $L_{j+i}$.

An important consequence of (1) is that, for any given $L_{i}$, the vertices $v$ with ranks less than $O(s_{i})$ (say, less than $s_{i}/16$) each have probability at least $\Omega(1)$ of being in $L_{i}$. We refer to the set of such vertices in $L_{i}$ as the anchor set $A_{i}$. At any given moment, we have with reasonably high probability that $|A_{i}|\geq s_{i}/128$.

The anchor sets $A_{i}$ play a critical role in ensuring that vertices with large ranks do not make it into low levels. Consider again a vertex $v$ with rank $r(v)\approx s_{j}$ and let us bound the probability that $v\in L_{j-c-i}$ for some $i\geq 0$. Assume for the moment that $v\in L_{j-c-i+1}$. The only way that $v$ can be promoted to $L_{j-c-i}$ is if there are no edges in $E_{j-c-i}$ that connect $v$ to an element of the anchor set $A_{j-i}$ (in particular, if there is such an edge, then $v$ will be blocked from promotion). However, the anchor set $A_{j-i}$ has size at least $s_{j-i}/128=\frac{2^{j-i}}{128p}$, and thus the expected number of edges (in all of $E$) from $v$ to $A_{j-i}$ is roughly $2^{j-i}/128$. A $1/2^{j-c-i}$ fraction of these edges are expected to be in $E_{j-c-i}$. Thus, the expected number of edges that block $v$ from promotion is roughly

$$\frac{2^{j-i}/128}{2^{j-c-i}}=2^{c}/128.$$

Since these edge-blockages are (mostly) independent, the probability that no such edges block $v$ from promotion ends up being at most

$$e^{-2^{c}/128}.$$

This analysis considers just the promotion of $v$ from level $L_{j-c-i+1}$ to level $L_{j-c-i}$. Applying the same analysis repeatedly, we get that for any vertex $v$ with rank $r(v)\approx s_{j}$, and any $i\geq 0$,

$$\Pr[v\in L_{j-c-i}]\leq e^{-2^{c}i/128}.$$

(2)

Or, to put it another way, for each level $L_{i}$, and for each vertex $v$ satisfying $r(v)\approx s_{i+k+c}$ for some $k\geq 0$, we have that

$$\Pr[v\in L_{i}]\leq e^{-2^{c}k/128}.$$

(3)

The derivation of (3) reveals an important insight in the algorithm’s design. One of the interesting features of the promotion rule is that, when deciding whether to promote a vertex $v$ from a given level $L_{i+1}$ into $L_{i}$, we use the edges in $E_{i}$ to compare $v$ not to its companions in $L_{i+1}$ (as might be tempting to do) but instead to the elements of the larger level $L_{i+c}$. For vertices $v$ with small ranks, this distinction has almost no effect on whether $v$ makes it into level $L_{i}$ (note, in particular, that the proof of (1) is unaffected by the choice of $c$!); but for vertices $v$ with large ranks (i.e., ranks at least $s_{i+c}$), this distinction makes the filtration process between levels much more effective (i.e., the larger that $c$ is, the stronger that (3) becomes). It is important that $c$ not be too large, however, since otherwise the application of (3) to a given $L_{i}$ would only tell us information about vertices $v$ with very large ranks. By setting $c$ to be a large positive constant, we get the best of all worlds.

The derivation of (3) also reveals the reason why we must perform periodic rebuilds of levels. We rely on the anchor set $A_{i+c}$ to ensure that vertices $v$ with large ranks stay out low levels $L_{i}$, but the anchor set $A_{i+c}$ changes dynamically. Since $A_{i+c}$ takes many different values over time, the result is that a given high-rank vertex $v$ might at some point get lucky and encounter a state of $A_{i+c}$ that allows for $v$ to get promoted to level $L_{i}$ (despite $v$’s large rank!). The main purpose of performing regular rebuilds is to ensure that this doesn’t happen, and in particular, that the vertices in level $L_{i}$ were all promoted into $L_{i}$ based on a relatively recent version of the anchor set $A_{i+c}$.

Combined, (1) and (3) give us a clear picture of which levels we should expect each vertex to be in. Now we turn our attention to analyzing the query complexity of the algorithm.

The next step of the analysis is to bound the number of queries spent rebuilding levels and performing incremental updates to them.

We can deduce from (3) that, at any given moment, $\mathbb{E}[|L_{i}|]=O(s_{i+c})=O(s_{i})$. For our discussion here we will simply assume that $|L_{i}|=O(s_{i})$ always holds.

Now let us consider the number of queries needed to perform a promotion test (i.e., to apply the promotion rule) on a given vertex $v$ in a given level $L_{i}$. The promotion rule requires us to examine every edge in $E_{i}$ that goes from $v$ to any vertex in $L_{i+c}$. The expected number of such edges is roughly

$$\frac{p}{2^{i}}|L_{i+c}|=O\left(\frac{p}{2^{i}}s_{i}\right)=O(1).$$

(4)

Thus we can treat each promotion test as taking $O(1)$ queries.

We can now easily bound the total work spent rebuilding levels from scratch. Each level $L_{i}$ is rebuilt $O(n/s_{i})$ times, and each rebuild requires us to apply the promotion rule to $O(s_{i})$ different vertices. It follows that each rebuild takes $O(s_{i})$ queries, and that the total number of queries spent performing rebuilds on $L_{i}$ is $O(n)$. Summing over the $O(\lg(pn))$ levels results in a total of $O(n\lg(pn))$ queries.

What about the query complexity of the incremental updates to the levels? Recall that whenever we discover a new $x_{\ell}$, we must revisit every vertex $v$ that was formerly blocked by $x_{\ell}$. For each such $v$, we must check whether $v$ can be promoted, and if so then we must repeatedly promote $v$ until it reaches a level where it is again blocked.

Recall that each promotion test takes $O(1)$ expected queries. To bound the total number of promotion tests due to incremental updates, we break the promotion tests into two categories: the failed promotion tests (i.e., the promotion tests that do not result in a promotion) and the successful promotion tests (i.e., the promotion tests that do result in a promotion).

The number of failed promotion tests is easy to bound. It is straightforward to show that the expected number of distinct vertices $v$ that we perform a promotion test on (each time that a new $x_{\ell}$ is discovered) is $O(\lg(pn))$ (roughly speaking, there will be one such vertex per level). Each such $v$ can contribute at most one failed promotion test. So summing over the $x_{\ell}$’s, we find that the total number of failed promotion tests is $O(n\lg(pn))$.

To bound the number of successful promotion tests, on the other hand, we can simply bound the number of promotions that occur (due to incremental updates). Each time that some vertex $v$ is promoted from a level $L_{i+1}$ to a level $L_{i}$, the size of $L_{i}$ increases by one (and the size of $L_{i+1}$ is unchanged). We know that the size of each $L_{i}$ stays below $O(s_{i})$ at all times, however, so there can be at most $O(s_{i})$ such promotions between every two consecutive rebuilds of the level. Since $L_{i}$ is rebuilt $O(n/s_{i})$ times, the total number of promotions into $L_{i}$ is $O(n)$. Summing over the levels, we get $O(n\lg(pn))$, as desired.

The final and most interesting step in the analysis is to bound the total number of queries spent eliminating candidates from candidate sets. Suppose we have already discovered vertices $x_{1},x_{2},\ldots,x_{\ell}$, and we wish to discover $x_{\ell+1}$. How many queries does it take to identify which element of $C$ is $x_{\ell+1}$?

For simplicity, we will assume here that all of the candidates $v\in C$ (besides $x_{\ell+1}$) have ranks at least $r(v)>1/p$ (this assumption can easily be removed with a bit of extra casework).

We can start by bounding the probability that a given $v$ is in $C$. In order for $v$ to be in $C$ we need both that $v\in L_{1}$ and that $(x_{\ell},v)$ is an edge. With a bit of manipulation, one can deduce from (3) that if a vertex $v$ has rank $r(v)\geq 1/p$, then

$$\Pr[v\in L_{1}]\leq O\left(\frac{1}{(r(v)\cdot p)^{10}}\right).$$

If $v\in L_{1}$ (but $v\neq x_{\ell+1}$), then $\Pr[(x_{\ell},v)\text{ is an edge}]=p$. Thus

$$\Pr[v\in C]\leq O\left(\frac{p}{(r(v)\cdot p)^{10}}\right).$$

If $v\in C$, then we must look at all of the edges from $v$ to the levels $L_{1},L_{2},\ldots$ until we find an edge $(u,v)$ with $u\prec v$. Since each level $L_{i}$ has size $O(s_{i})$, the expected number of edges from $v$ to a given $L_{i}$ is $O(ps_{i})=O(2^{i})$. If $L_{J}$ is the highest level that we look at while eliminating $v$ from $C$, then the total number of queries incurred will be roughly $O(2^{J}).$

So how many levels must we look at in order to eliminate $v$ from $C$? Let $u$ be the predecessor to $v$ in the true order, and let $L_{K}$ be the lowest level that contains $u$. Since $u\prec v$ and since $(u,v)$ is deterministically an edge, we are guaranteed to stop at a level $J\leq K$. We can bound $K$ (and thus $J$) by applying (1); this gives us the identity

$$\Pr[J\geq\lg(p\cdot r(v))+i]\leq O\left(1/2^{i}\right)$$

(5)

for every $i\geq 0$.

To summarize, if $v\in C$ (and $v\neq x_{\ell+1}$), then the expected number of queries to remove $v$ from $C$ is roughly $\mathbb{E}[2^{J}]$; and for any $i\geq 0$, the probability that $2^{J}\geq pr(v)2^{i}$ is $O(1/2^{i})$. There are $O(\lg pn)$ possible values for $i$, each of which contributes $O(p\cdot r(v))$ to $\mathbb{E}[2^{J}]$. Thus the expected number of queries to remove $v$ from $C$ is $O(p\cdot r(v)\lg(pn))$.

To bound the cost of eliminating all candidates from $C$, we must sum over the ranks $r\geq p^{-1}$ to get

$${\sum_{v:r(v)\geq p^{-1}}\Pr[v\in C]\cdot\mathbb{E}[2^{J}]}=O\left(\sum_{r\geq p^{-1}}\frac{p}{(rp)^{9}}\lg(pn)\right)=O\left(\lg(pn)\right).$$

This represents the cost to identify a given $x_{\ell+1}$. Summing over all $\ell$, the total contribution of these costs to the query complexity of the algorithm of is $O(n\lg(pn))$.