Quantum routing with fast reversals

Abstract

We present methods for implementing arbitrary permutations of qubits under interaction constraints. Our protocols make use of previous methods for rapidly reversing the order of qubits along a path. Given nearest-neighbor interactions on a path of length $n$, we show that there exists a constant $ϵ\approx 0.034$ such that the quantum routing time is at most $(1-ϵ)n$, whereas any SWAP-based protocol needs at least time $n-1$. This represents the first known quantum advantage over swAP-based routing methods and also gives improved quantum routing times for realistic architectures such as grids. Furthermore, we show that our algorithm approaches a quantum routing time of $2n/3$ in expectation for uniformly random permutations, whereas SWAP-based protocols require time $n$ asymptotically. Additionally, we consider sparse permutations that route $k\le n$ qubits and give algorithms with quantum routing time at most $n/3+O\left(k^2\right)$ on paths and at most $2r/3+O\left(k^2\right)$ on general graphs with radius $r$.

1. Introduction

Qubit connectivity limits quantum information transfer, which is a fundamental task for quantum computing. While the common model for quantum computation usually assumes all-to-all connectivity, proposals for scalable quantum architectures do not have this capability [MK13; Mon +14; Bre+16]. Instead, quantum devices arrange qubits in a fixed architecture that fits within engineering and design constraints. For example, the architecture may be grid-like [MG19; Aru +19] or consist of a network of submodules [MK13; Mon+14]. Circuits that assume all-to-all qubit connectivity can be mapped onto these architectures via protocols for routing qubits, i.e., permuting them within the architecture using local operations.

Long-distance gates can be implemented using SWAP gates along edges of the graph of available interactions. A typical procedure swaps pairs of distant qubits along edges until they are adjacent, at which point the desired two-qubit gate is applied on the target qubits. These swap subroutines can be sped up by parallelism and careful scheduling [SWD11; SSP13; SSP14; PS16; LWD15; Mur+19; ZW19]. Minimizing the sWaP circuit depth corresponds to the Routing ViA Matchings problem [ACG94; CSU19]. The minimal swAP circuit depth to implement any permutation on a graph $G$ is given by its routing number, $\mathrm{r}\mathrm{t}\left(G\right)$ [ACG94]. Deciding $\mathrm{r}\mathrm{t}\left(G\right)$ is generally NP-hard [BR17], but there exist algorithms for architectures of interest such as grids and other graph products [ACG94; Zha99; CSU19]. Furthermore, one can establish lower bounds on the routing number as a function of graph diameter and other properties.

Routing using SWAP gates does not necessarily give minimal circuit evolution time since it is effectively classical and does not make use of the full power of quantum operations. Indeed, faster protocols are already known for specific permutations in specific qubit geometries such as the path [Rau05; Bap +20]. These protocols tend to be carefully engineered and do not generalize readily to other permutations, leaving open the general question of devising faster-than-SWAP quantum routing. In this paper, we give a positive answer to this question.

Following [Rau05; Bap+20], we consider a continuous-time model of routing, where the protocol is defined by a Hamiltonian that can only include nearest-neighbor interactions. To make consistent comparisons with a gate-based model of routing, we bound the spectral norm of interactions [Bap+20] so that a SWAP gate takes unit time [VHC02], as determined by the canonical form of a two-qubit Hamiltonian [Ben+02]. We suppose that single-qubit operations can be performed arbitrarily fast, a common assumption [VHC02; Ben+02] that is practically well-motivated due to the relative ease of implementing single-qubit rotations.

Rather than directly engineering a quantum routing protocol, we consider a hybrid strategy that leverages a known protocol for quickly performing a specific permutation to implement general quantum routing. Specifically, we consider the reversal operation

$$\rho :=\prod _{k=1}^{⌊\frac{n}{2}⌋}{\mathrm{S}\mathrm{W}\mathrm{A}\mathrm{P}}_{k,n+1-k}$$ (1)

that swaps the positions of qubits about the center of a length-$n$ path. Fast quantum reversal protocols are known in the gate-based [Rau05] and time-independent Hamiltonian [Bap+20] settings. The reversal operation can be implemented in time [Bap+20]

$$T\left(\rho \right)\le \frac{\sqrt{(n+1{)}^2-p(n)}}{3}\le \frac{n+1}{3},$$ (2)

where $p\left(n\right)\in \{0,1\}$ is the parity of $n$. Both protocols exhibit an asymptotic time scaling of $n/3+O\left(1\right)$, which is asymptotically three times faster than the best possible swaP-based time of $n-1$ (bounded by the diameter of the graph) [ACG94]. The odd-even sort algorithm provides a nearly tight time upper bound of $n$ [LDM84] and will be our main point of comparison.

The Hamiltonian protocol of [Bap+20] can be understood by looking at the time evolution of the site Majorana operators obtained by a Jordan-Wigner transformation of the spin chain. In this picture, the protocol can be interpreted as the rotation of a fictitious particle of spin $n+1/2$ whose magnetization components are in one-to-one correspondence with the Majoranas on the chain. A reversal corresponds to a rotation of the large spin by an angle of $\pi$. The gate-based reversal protocol [Rau05] is a special case of a quantum cellular automaton with a transition function given by the $(n+1)$-fold product of nearest-neighbor controlled-Z (CZ) operations—an operation that can be done 3 times faster than a SWAP gate—and Hadamard operations. In an open spin chain, this process spreads out local Pauli observables at site $i$ over the chain and “refocuses” them at site $n+1-i$ in $n+1$ steps for every $i$. The ability to spread local observables (which is present in the gate-based and Hamiltonian protocols but not in SWAP-based protocols) may be key to obtaining a speedup over SWAP-based algorithms.

We expect both the gate-based and Hamiltonian protocols to be implementable on near-term quantum devices. The gate-based protocol uses nearest-neighbor CZ gates and Hadamard gates, both of which are widely used on existing quantum platforms. The Hamiltonian protocol involves nearest-neighbor Pauli XX interactions with non-uniform couplings, which is within the capabilities of, e.g., superconducting architectures [Kja+20].

Routing using reversals has been studied extensively due to its applications in comparative genomics (where it is known as sorting by reversals) [BP93; KS95]. References [Ben+08; PS02; NNN05] present routing algorithms where, much like in our case, reversals have length-weighted costs. However, these models assume reversals are performed sequentially, while we assume independent reversals can be performed in parallel, where the total cost is given by the evolution time, akin to circuit depth. To our knowledge, results from the sequential case are not easily adaptable to the parallel setting and require a different approach.

Routing on paths is a fundamental building block for routing on more general graphs. For example, a two-dimensional grid graph is the Cartesian product of two path graphs, and the best known routing routine applies a path routing subroutine 3 times [ACG94]. A quantum protocol for routing on the path in time $cn$, for a constant $c>0$, would imply a routing time of $3cn$ on the grid. A similar speedup follows for higher-dimensional grids. More generally, routing algorithms for the generalized hierarchical product of graphs can take advantage of faster routing of the path base graph [CSU19]. For other graphs, it is open whether fast reversals can be used to give faster routing protocols for general permutations.

In the rest of this paper, we present the following results on quantum routing using fast reversals. In Section 2, we give basic examples of using fast reversals to perform routing on general graphs to indicate the extent of possible speedup over swAP-based routing, namely a graph for which routing can be sped up by a factor of 3, and another for which no speedup is possible. Section 3 presents algorithms for routing sparse permutations, where few qubits are routed, both for paths and for more general graphs. Here, we obtain the full factor 3 speedup over swAP-based routing. Then, in Section 4, we prove the main result that there is a quantum routing algorithm for the path with worst-case constant-factor advantage over any swAP-based routing scheme. Finally, in Section 5, we show that our algorithm has average-case routing time $2n/3+o\left(n\right)$ and any swAP-based protocol has average-case routing time at least $n-o\left(n\right)$.

2. Simple bounds on routing using reversals

Given the ability to implement a fast reversal $\rho$ with cost given by Eq. (2), the largest possible asymptotic speedup of reversal-based routing over swAP-based routing is a factor of 3. This is because the reversal operation, which is a particular permutation, cannot be performed faster than $n/3+o\left(n\right)$, and can be performed in time $n$ classically using odd-even sort. As we now show, some graphs can saturate the factor of 3 speedup for general permutations, while other graphs do not admit any speedup over swaps

Maximal speedup:

For $n$ odd, let $K_n^{\mathrm{*}}$ denote two complete graphs, each on $(n+1)/2$ vertices, joined at a single “junction” vertex for a total of $n$ vertices (Figure 1a). Consider a permutation on $K_n^{\mathrm{*}}$ in which every vertex is sent to the other complete subgraph, except that the junction vertex is sent to itself. To route with SWAPs, note that each vertex (other than that at the junction) must be moved to the junction at least once, and only one vertex can be moved there at any time. Because there are $(n+1)/2-1$ non-junction vertices on each subgraph, implementing this permutation requires a SWAP-circuit depth of at least $n-1$.

Figure 1:

$K_9^{\mathrm{*}}$ admits the full factor of 3 speedup in the worst case when using reversals over swAPs, whereas $K_5$ admits no speedup when using reversals over SWAPS.

On the other hand, any permutation on $K_n^{\mathrm{*}}$ can be implemented in time $n/3+O\left(1\right)$ using reversals. First, perform a reversal on a path that connects all vertices with opposite-side destinations. After this reversal, every vertex is on the side of its destination and the remainder can be routed in at most 2 steps [ACG94]. The total time is at most $(n+1)/3+2$, exhibiting the maximal speedup by an asymptotic factor of 3.

No speedup:

Now, consider the complete graph on $n$ vertices, $K_n$ (Figure 1b). Every permutation on $K_n$ can be routed in at most time 2 using swAPs [ACG94]. Consider implementing a 3-cycle on three vertices of $K_n$ for $n\ge 3$ using reversals. Any reversal sequence that implements this permutation will take at least time 2. Therefore, no speedup is gained over swAPs in the worst case.

We have shown that there exists a family of graphs that allows a factor of 3 speedup for any permutation when using fast reversals instead of SWAPs, and others where reversals do not grant any improvement. The question remains as to where the path graph lies on this spectrum. Faster routing on the path is especially desirable since this task is fundamental for routing in more complex graphs.

3. An algorithm for sparse permutations

We now consider routing sparse permutations, where only a small number $k$ of qubits are to be moved. For the path, we show that the routing time is at most $n/3+O\left(k^2\right)$. More generally, we show that for a graph of radius $r$, the routing time is at most $2r/3+O\left(k^2\right)$. (Recall that the radius of a graph $G=(V,E)$ is ${\mathrm{m}\mathrm{i}\mathrm{n}}_{u\in V}.{\mathrm{m}\mathrm{a}\mathrm{x}}_{v\in V}.\mathrm{d}\mathrm{i}\mathrm{s}\mathrm{t}(u,v)$, where $\mathrm{d}\mathrm{i}\mathrm{s}\mathrm{t}(u,v)$ is the distance between $u$ and $v$ in $G$.) Our approach to routing sparse permutations using reversals is based on the idea of bringing all $k$ qubits to be permuted to the center of the graph, rearranging them, and then sending them to their respective destinations.

3.1. Paths

A description of the algorithm on the path, called MiddleExchange, appears in Algorithm 3.1. Figure 2 presents an example of MiddleExchange for $k=6$.

Figure 2:

Example of MiddleExchange (Algorithm 3.1) on the path for $k=6$.

In Theorem 3.1, we prove that Algorithm 3.1 achieves a routing time of asymptotically $n/3$ when implementing a sparse permutation of $k=o\left(\sqrt{n}\right)$ qubits on the path graph. First, let ${𝒮}_n$ denote the set of permutations on $\{1,\dots ,n\}$, so $\left|{𝒮}_n\right|=n$ !. Then, for any permutation $\pi \in {𝒮}_n$ that acts on a set of labels $\{1,\dots ,n\}$, let ${\pi }_i$ denote the destination of label $i$ under $\pi$. We may then write $\pi =\left({\pi }_1,{\pi }_2,\dots ,{\pi }_n\right)$. Let $\bar{\rho }$ denote an ordered series of reversals ${\rho }_1,\dots ,{\rho }_m$, and let ${\overline{\rho }}_1\sout{\parallel }{\overline{\rho }}_2$ be the concatenation of two reversal series. Finally, let $S·\rho$ and $S·\bar{\rho }$ denote the result of applying $\rho$ and $\bar{\rho }$ to a sequence $S$, respectively, and let $\left|\rho \right|$ denote the length of the reversal $\rho$, i.e., the number of vertices it acts on.

Theorem 3.1.

Let $\pi \in {𝒮}_n$ with $k=\left|\left\{x\in \left[n\right]\mid {\pi }_x\ne x\right\}\right|$ (i.e., $k$ elements are to be permuted, and $n-k$ elements begin at their destination). Then Algorithm 3.1 routes $\pi$ in time at most $n/3+O\left(k^2\right)$.

Proof.

Algorithm 3.1 consists of three steps: compression (Line 4–Line 9), inner permutation (Line 11), and dilation (Line 12). Notice that compression and dilation are inverses of each other.

Let us first show that Algorithm 3.1 routes $\pi$ correctly. Just as in the algorithm, let $x_1,\dots ,x_k$ denote the labels $x\in \left[n\right]$ with $x_i<x_{i+1}$ such that ${\pi }_x\ne x$, that is, the elements that do not begin at their destination and need to be permuted. It is easy to see that these elements are permuted correctly: After compression, the inner permutation step routes $x_i$ to the current location of the label ${\pi }_{x_i}$ in the middle. Because dilation is the inverse of compression, it will then route every $x_i$ to its correct destination. For the non-permuting labels, notice that they lie in the support of either no reversal or exactly two reversals, ${\rho }_1$ in the compression step and ${\rho }_2$ in the dilation step. Therefore ${\rho }_1$ reverses the segment containing the label and ${\rho }_2$ re-reverses it back into place (so ${\rho }_1={\rho }_2$). Therefore, the labels that are not to be permuted end up exactly where they started once the algorithm is complete.

Now we analyze the routing time. Let $d_i=x_{i+1}-x_i-1$ for $i\in [k-1]$. As in the algorithm, let $t$ be the largest index for which $x_t\le \lfloor n/2\rfloor$. Then, for $1\le i\le t-1$, we have $\left|{\rho }_i\right|=d_i+i$, and, for $t+2\le j\le k$, we have $\left|{\rho }_j\right|=d_{j-1}+k-j$. Moreover, we have $\left|{\rho }_t\right|=\lfloor n/2\rfloor -x_t-1+t$ and $\left|{\rho }_{t+1}\right|=x_{t+1}-\lfloor n/2\rfloor +k-t$. From all reversals in the first part of Algorithm 3.1, $\bar{\rho }$, consider those that are performed on the left side of the median (position $\lfloor n/2\rfloor$ of the path). The routing time of these reversals is

$$\begin{array}{l}\frac{1}{3}\sum _{i=1}^t\left|{\rho }_i\right|+1=\frac{1}{3}\left(\lfloor n/2\rfloor -x_t-1\right)+\frac{1}{3}\sum _{i=1}^t\left(d_i+i+1\right)\\ =\frac{t(t+1)}{6}+\frac{1}{3}\left(\lfloor n/2\rfloor -x_t-1\right)+\sum _{i=1}^t\left(x_{i+1}-x_i\right)\\ =O\left(t^2\right)+\frac{1}{3}\left(\lfloor n/2\rfloor -x_1\right)\\ \le \frac{n}{6}+O\left(k^2\right).\end{array}$$ (3)

By a symmetric argument, the same bound holds for the compression step on the right half of the median. Because both sides can be performed in parallel, the total cost for the compression step is at most $n/6+O\left(k^2\right)$. The inner permutation step can be done in time at most $k$ using odd-even sort. The cost to perform the dilation step is also at most $n/6+O\left(k^2\right)$ because dilation is the inverse of compression. Thus, the total routing time for Algorithm 3.1 is at most $2\left(n/6+O\left(k^2\right)\right)+k=n/3+O\left(k^2\right)$. □

It follows that sparse permutations on the path with $k=o\left(\sqrt{n}\right)$ can be implemented using reversals with a full asymptotic factor of 3 speedup.

3.2. General graphs

We now present a more general result for implementing sparse permutations on an arbitrary graph.

Theorem 3.2.

Let $G=(V,E)$ be a graph with radius $r$ and $\pi$ a permutation of vertices. Let $S=\left\{v\in V:{\pi }_v\ne v\right\}$. Then $\pi$ can be routed in time at most $2r/3+O(|S{|}^2)$.

Proof.

We route $\pi$ using a procedure similar to Algorithm 3.1, consisting of the same three steps adapted to work on a spanning tree of $G$: compression, inner permutation, and dilation. Dilation is the inverse of compression and the inner permutation step can be performed on a subtree consisting of just $k=\left|S\right|$ nodes by using the Routing ViA MATCHings algorithm for trees in $3k/2+O(\mathrm{l}\mathrm{o}\mathrm{g}k)$ time [Zha99]. It remains to show that compression can be performed in $r/3+O\left(k^2\right)$ time.

We construct a token tree $𝒯$ that reduces the compression step to routing on a tree. Let $c$ be a vertex in the center of $G$, i.e., a vertex with distance at most $r$ to all vertices. Construct a shortest-path tree ${𝒯}^{\prime }$ of $G$ rooted at $c$, say, using breadth-first search. We assign a token to each vertex in $S$. Now $𝒯$ is the subtree of ${𝒯}^{\prime }$ formed by removing all vertices $v\in V\left({𝒯}^{\prime }\right)$ for which the subtree rooted at $v$ does not contain any tokens, as depicted in Figure 3. In $𝒯$, call the first common vertex between paths to $c$ from two distinct tokens an intersection vertex, and let $ℐ$ be the set of all intersection vertices. Note that if a token $t_1$ lies on the path from another token $t_2$ to $c$, then the vertex on which $t_1$ lies is also an intersection vertex. Since $𝒯$ has at most $k$ leaves, $\left|ℐ\right|\le k-1$.

Figure 3:

Illustration of the token tree $𝒯$ in Theorem 3.2 for a case where $G$ is the 5 × 5 grid graph. Blue circles represent vertices in $S$ and orange circles represent vertices not in $S$. Vertex $c$ denotes the center of $G$. Red-outlined circles represent intersection vertices. In particular, note that one of the blue vertices is an intersection because it is the first common vertex on the path to $c$ of two distinct blue vertices.

For any vertex $v$ in $𝒯$, let the descendants of $v$ be the vertices $u\ne v$ in $𝒯$ whose path on $𝒯$ to $c$ includes $v$. Now let ${𝒯}_v$ be the subtree of $𝒯$ rooted at $v$, i.e., the tree composed of $v$ and all of the descendants of $v$. We say that all tokens have been moved up to a vertex $v$ if for all vertices $u$ in ${𝒯}_v$ without a token, $T_u$ also does not contain a token. The compression step can then be described as moving tokens up to $c$.

We describe a recursive algorithm for doing so in Algorithm 3.2. The base case considers the trivial case of a subtree with only one token. Otherwise, we move all tokens on the subtrees of descendant $b$ up to the closest intersection $w$ using recursive calls as illustrated in Figure 4. Afterwards, we need to consider whether the path $p$ between $v$ and $w$ has enough room to store all tokens. If it does, we use a Routing via Matchings algorithm for trees to route tokens from $w$ onto $p$, followed by a reversal to move these tokens up to $v$. Otherwise, the path is short enough to move all tokens up to $v$ by the same Routing via Matchings algorithm.

Figure 4:

An example of moving the $m$ tokens in ${𝒯}_w$ up to $b$ (Line 14-Line 18 in Algorithm 3.2).

We now bound the routing time on ${𝒯}_{w_1}$ of MoveUpTo $\left(w_1\right)$, for any vertex $w_1\in V\left(𝒯\right)$. First note that all operations on subtrees ${𝒯}_b$ of ${𝒯}_{w_1}$ are independent and can be performed in parallel. Let $w_1,w_2,\dots ,w_t$ be the sequence of intersection vertices that MoveUpTo(·) is recursively called on that dominates the routing time of MoveUpTo $\left(w_1\right)$. Let $d_w$, for $w\in V\left({𝒯}_{w_1}\right)$, be the distance of $w$ to the furthest leaf node in ${𝒯}_w$. Assuming that the base case on Line 2 has not been reached, we have a routing time of

$$T\left(w_1\right)\le T\left(w_2\right)+\frac{d_{w_1}-d_{w_2}}{3}+O(k),$$ (4)

where $O\left(k\right)$ bounds the time required to route $m\le k$ tokens on a tree of size at most $2m$ following the recursive MoveUpTo $\left(w_2\right)$ call [Zha99]. We expand the time cost $T\left(w_i\right)$ of recursive calls until we reach the base case of $w_t$ to obtain

$$T\left(v\right)\le T\left(w_t\right)+\sum _{i=1}^{t-1}\left(\frac{d_{w_i}-d_{w_{i+1}}}{3}+O\left(k\right)\right)=T\left(w_t\right)+\frac{d_{w_1}-d_{w_t}}{3}+t·O\left(k\right)\le \frac{d_{w_1}}{3}+\left(t+1\right)O\left(k\right).$$ (5)

Since $d_v\le r$ and $t\le k$, this shows that compression can be performed in $r/3+O\left(k^2\right)$ time. □

In general, a graph with radius $r$ and diameter $d$ will have $d/2\le r\le d$. Using Theorem 3.2, this implies that for a graph $G$ and a sparse permutation with $k=o\left(\sqrt{r}\right)$, the bound for the routing time will be between $d/3+o\left(d\right)$ and $2d/3+o\left(d\right)$. Thus, for such sparse permutations, using reversals will always asymptotically give us a constant-factor worst-case speedup over any swAP-only protocol since $\mathrm{r}\mathrm{t}\left(G\right)\ge d$. Furthermore, for graphs with $r=d/2$, we can asymptotically achieve the full factor of 3 speedup.

4. Algorithms for routing on the path

Our general approach to implementing permutations on the path relies on the divide-and-conquer strategy described in Algorithm 4.1. It uses a correspondence between implementing permutations and sorting binary strings, where the former can be performed at twice the cost of the latter. This approach is inspired by [PS02] and [Ben+08] who use the same method for routing by reversals in the sequential case.

First, we introduce a binary labeling using the indicator function

$$I(v)=\left\{\begin{array}{ll}0& \text{if}v<n/2,\\ 1& \text{otherwise.}\end{array}\right.$$ (6)

This function labels any permutation $\pi \in {𝒮}_n$ by a binary string $I\left(\pi \right):=\left(I\left({\pi }_1\right),I\left({\pi }_2\right),\dots ,I\left({\pi }_n\right)\right)$. Let $\pi$ be the target permutation, and $\sigma$ any permutation such that $I\left(\pi {\sigma }^{-1}\right)=(0^{\lfloor n/2\rfloor }{1}^{\lceil n/2\rceil })$. Then it follows that $\sigma$ divides $\pi$ into permutations ${\pi }_L$, ${\pi }_R$ acting only on the left and right halves of the path, respectively, i.e., $\pi ={\pi }_L·{\pi }_R·\sigma$. We find and implement $\sigma$ via a binary sorting subroutine, thereby reducing the problem into two subproblems of length at most $\lceil n/2\rceil$ that can be solved in parallel on disjoint sections of the path. Proceeding by recursion until all subproblems are on sections of length at most 1, the only possible permutation is the identity and $\pi$ has been implemented. Because disjoint permutations are implemented in parallel, the total routing time is $T\left(\pi \right)=T\left(\sigma \right)+\mathrm{m}\mathrm{a}\mathrm{x}\left(T\left({\pi }_L\right),T\left({\pi }_R\right)\right)$.

We illustrate Algorithm 4.1 with an example, where the binary labels are indicated below the corresponding destination indices:

(7)

Each labeling and sorting step corresponds to an application of Eq. (6) and BinarySorter, respectively, to each subproblem. Specifically, in Eq. (7), we use TBS (Algorithm 4.2) to sort binary strings.

We present two algorithms for BinarySorter, which perform the work in our sorting algorithm. The first of these binary sorting subroutines is Tripartite Binary Sort (TBS, Algorithm 4.2). TBS works by splitting the binary string into nearly equal (contiguous) thirds, recursively sorting these thirds, and merging the three sorted thirds into one sorted sequence. We sort the outer thirds forwards and the middle third backwards which allows us to merge the three segments using at most one reversal. For example, we can sort a binary string as follows:

(8)

where the arrows with TBS indicate recursive calls to TBS and the bracket indicates the reversal to merge the segments. Let GDC (TBS) denote Algorithm 4.1 when using TBS to sort binary strings, where GDC stands for GenericDivideConquer.

The second algorithm is an adaptive version of TBS (Algorithm 4.3) that, instead of using equal thirds, adaptively chooses the segments’ length. Adaptive TBS considers every pair of partition points, $0\le i\le j<n-1$, that would split the binary sequence into two or three sections: $B[0,i]$, $B[i+1,j]$, and $B[j+1,n-1]$ (where $i=j$ corresponds to no middle section). For each pair, it calculates the minimum cost to recursively sort the sequence using these partition points. Since each section can be sorted in parallel, the total sorting time depends on the maximum time needed to sort one of the three sections and the cost of the final merging reversal. Let GDC(ATBS) denote Algorithm 4.1 when using Adaptive TBS to sort binary strings.

Notice that the partition points selected by TBS are considered by the Adaptive TBS algorithm and are selected by Adaptive TBS only if no other pair of partition points yields a faster sorting time. Thus, for any permutation, the sequence of reversals found by Adaptive TBS costs no more than that found by TBS. However, TBS is simpler to implement and will be faster than Adaptive TBS in finding the sorting sequence of reversals.

4.1. Worst-case bounds

In this section, we prove that all permutations of sufficiently large length $n$ can be sorted in time strictly less than $n$ using reversals. Let $n_x\left(b\right)$ denote the number of times character $x\in \{0,1\}$ appears in a binary string $b$, and let $T\left(b\right)$ (resp., $T\left(\pi \right)$) denote the best possible sorting time to sort $b$ (resp., implement $\pi$) with reversals. Assume all logarithms are base 2 unless specified otherwise.

Lemma 4.1.

Let $b\in \{0,1{\}}^n$ such that $n_x\left(b\right)<cn+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$, where $c\in [0,1/3]$ and $x\in \{0,1\}$. Then, $T\left(b\right)\le (c/3+7/18)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$.

Proof.

To achieve this upper bound, we use TBS (Algorithm 4.2). There are $⌊{\mathrm{l}\mathrm{o}\mathrm{g}}_{3}n⌋$ steps in the recursion, which we index by $j\in \left\{0,1,\dots ,⌊{\mathrm{l}\mathrm{o}\mathrm{g}}_{3}n⌋\right\}$, with step 0 corresponding to the final merging step. Let $\left|{\rho }_j\right|$ denote the size of the longest reversal in recursive step $j$ that merges the three sorted subsequences of size $n/3^{j+1}$. The size of the final merging reversal ${\rho }_0$ can be bounded above by $(c+2/3)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$ because $\left|{\rho }_0\right|$ is maximized when every $x$ is contained in the leftmost third if $x=1$ or the rightmost third if $x=0$. So we have

$$T\left(b\right)\le \left(\sum _{j=0}^{{\text{log}}_{3}n}\frac{\left|{\rho }_j\right|}{3}\right)+O\left(\text{log}n\right)\le \left(\frac{c}{3}+\frac{2}{9}\right)n+O\left(\text{log}n\right)+\left(\sum _{j=1}^{{\text{log}}_{3}n}\frac{\left|{\rho }_j\right|}{3}\right)+O\left(\text{log}n\right)$$ (9)

$$\le \left(\frac{c}{3}+\frac{7}{18}\right)n+O\left(\log n\right),$$ (10)

where we used $\left|{\rho }_j\right|\le n/3^j$ for $j\ge 1$. □

Now we can prove a bound on the cost of a sorting series found by Adaptive TBS for any binary string of length $n$.

Theorem 4.2.

For all bit strings $b\in \{0,1{\}}^n$ of arbitrary length $\in \mathbb{N}$, $T\left(b\right)\le \left(\frac{1}{2}-\epsilon \right)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)\approx 0.483n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$, where $\epsilon =1/3-1/\sqrt{10}$.

Proof.

Let $b\in \{0,1{\}}^n$ for some $n\in \mathbb{N}$. Partition $b$ into three sections $b=b_1{b}_2{b}_3$ such that $\left|b_1\right|=\left|b_3\right|=\lfloor n/3\rfloor$ and $\left|b_2\right|=n-2\lfloor n/3\rfloor$. Since $\lfloor n/3\rfloor =n/3-d$ where $d\in \{0,1/3,2/3\}$, we write $\left|b_1\right|=\left|b_2\right|=\left|b_3\right|=n/3+O\left(1\right)$ for the purposes of this proof. Recall that if segments $b_1$ and $b_3$ are sorted forwards and segment $b_2$ is sorted backwards, the resulting segment can be sorted using a single reversal, $\rho$ (see the example in Eq. (8)). Then we have

$$T(b)\le \mathrm{m}\mathrm{a}\mathrm{x}\left(T\left(b_1\right),T^{\prime }\left(b_2\right),T\left(b_3\right)\right)+\frac{\left|\rho \right|+1}{3},$$ (11)

where $T^{\prime }\left(b_2\right)$ is the time to sort $b_2$ backwards using reversals.

We proceed by induction on $n$. For the base case, it suffices to note that every binary string can be sorted using reversals and, for finitely many values of $n\in \mathbb{N}$, any time needed to sort a binary string of length $n$ exceeding $(1/2-\epsilon )n$ can be absorbed into the $O(\mathrm{l}\mathrm{o}\mathrm{g}n)$ term. Now assume $T\left(b\right)\le (1/2-\epsilon )k+O(\mathrm{l}\mathrm{o}\mathrm{g}k)$ for all $<n$, $b\in \{0,1{\}}^k$.

Case 1:

$n_0\left(b_1\right)\ge 2\epsilon n$ or $n_1\left(b_3\right)\ge 2\epsilon n$. In this case, $\left|\rho \right|\le n-2\epsilon n$, so

$$T(b)\le \frac{n-2\epsilon n+1}{3}+\mathrm{m}\mathrm{a}\mathrm{x}\left(T\left(b_1\right),T^{\prime }\left(b_2\right),T\left(b_3\right)\right)\le \left(\frac{1}{2}-\epsilon \right)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$$ (12)

by the induction hypothesis.

Case 2:

$n_0\left(b_1\right)<2\epsilon n$ and $n_1\left(b_3\right)<2\epsilon n$. In this case, adjust the partition such that $\left|b_1\right|=\left|b_3\right|=n/3+2\epsilon n/(3-6\epsilon )-O\left(1\right)$ and consequently $\left|b_2\right|=n/3-4\epsilon n/(3-6\epsilon )+O\left(1\right)$, as depicted in Figure 5. In this adjustment, at most $2\epsilon n/(3-6\epsilon )$ zeros are added to the segment $b_1$ and likewise with ones to $b_3$. Thus, $n_1\left(b_3\right)\le 2\epsilon n+2\epsilon n/(3-6\epsilon )=(1+1/(3-6\epsilon \left)\right)2\epsilon n$. Since $n=(3-6\epsilon )\left|b_1\right|-O\left(1\right)$, we have

$$n_1\left(b_3\right)\le \left(1+\frac{1}{3-6\epsilon }\right)2\epsilon \left((3-6\epsilon )\left|b_1\right|-O(1)\right)=(2-3\epsilon )4\epsilon \left|b_1\right|-O(1).$$ (13)

Let $c=(2-3\epsilon )4\epsilon =2/15$. Applying Lemma 4.1 with this value of $c$ yields

$$T\left(b_3\right)\le \left(\frac{2}{45}+\frac{7}{18}\right)\left|b_1\right|+O\left(\mathrm{l}\mathrm{o}\mathrm{g}\left(\left|b_1\right|\right)\right)=\left(\frac{1}{\sqrt{10}}-\frac{1}{6}\right)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n).$$ (14)

Since $\left|b_1\right|=\left|b_3\right|$, we obtain the same bound $T\left(b_1\right)\le (1/\sqrt{10}-1/6)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$ by applying Lemma 4.1 with the same value of $c$.

Figure 5:

Case 2 of Theorem 4.2. If there are few zeros and ones in the leftmost and rightmost thirds, respectively, we can shorten the middle section so that it can be sorted quickly. Then, because each of the outer thirds contain far more zeros than ones (or vice versa), they can both can be sorted quickly as well.

By the inductive hypothesis, $T^{\prime }\left(b_2\right)$ can be bounded above by

$$T^{\prime }\left(b_2\right)\le \left(\frac{1}{2}-\epsilon \right)\left(\frac{n}{3}-\frac{4\epsilon }{3-6\epsilon }n+O(1)\right)+O(\mathrm{l}\mathrm{o}\mathrm{g}n)=\left(\frac{1}{\sqrt{10}}-\frac{1}{6}\right)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n).$$ (15)

Using Eq. (11) and the fact that $\left|\rho \right|\le n$, we get the bound

$$T(b)\le \left(\frac{1}{\sqrt{10}}-\frac{1}{6}\right)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)+\frac{n+1}{3}=\left(\frac{1}{2}-\epsilon \right)n+O(\mathrm{l}\mathrm{o}\mathrm{g}n)$$

as claimed. □

This bound on the cost of a sorting series found by Adaptive TBS for binary sequences can easily be extended to a bound on the minimum sorting sequence for any permutation of length $n$.

Corollary 4.3.

For a length-n permutation $\pi ,T(\pi )\le (1/3+\sqrt{2/5})n+O\left({\mathrm{l}\mathrm{o}\mathrm{g}}^{2}n\right)\approx 0.9658n+O\left({\mathrm{l}\mathrm{o}\mathrm{g}}^{2}n\right)$.

Proof.

To sort $\pi$, we turn it into a binary string $b$ using Eq. (6). Then let ${\rho }_1,{\rho }_2,\dots ,{\rho }_m$ be a sequence of reversals to sort $b$. If we apply the sequence to get ${\pi }^{\prime }=\pi {\rho }_1{\rho }_2\cdots {\rho }_m$, every element of ${\pi }^{\prime }$ will be on the same half as its destination. We can then recursively perform the same procedure on each half of ${\pi }^{\prime }$, continuing down until every pair of elements has been sorted.

This process requires $\lfloor \mathrm{l}\mathrm{o}\mathrm{g}n\rfloor$ steps, and at step $i$, there are $2^i$ binary strings of length $\frac{n}{2^i}$ being sorted in parallel. This gives us the following bound to implement $\pi$:

$$T\left(\pi \right)\le \sum _{i=0}^{\text{log}n}T\left(b_i\right),$$ (16)

where $b_i\in \{0,1{\}}^{n/2^i}$. Applying the bound from Theorem 4.2, we obtain

$$T\left(\pi \right)\le \sum _{i=0}^{\text{log}n}T\left(b_i\right)\le \sum _{i=0}^{\text{log}n}\left(\left(\frac{1}{6}+\frac{1}{\sqrt{10}}\right)\frac{n}{2^i}+O\left(\text{log}\left(n/2^i\right)\right)\right)=\left(\frac{1}{3}+\sqrt{\frac{2}{5}}\right)n+O\left({\text{log}}^{2}n\right).\square$$

5. Average-case performance

So far we have presented worst-case bounds that provide a theoretical guarantee on the speedup of quantum routing over classical routing. However, the bounds are not known to be tight, and may not accurately capture the performance of the algorithm in practice.

In this section we show better performance for the average-case routing time, the expected routing time of the algorithm on a permutation chosen uniformly at random from ${𝒮}_n$. We present both theoretical and numerical results on the average routing time of swap-based routing (such as odd-even sort) and quantum routing using TBS and ATBS. We show that on average, GDC (TBS) (and GDC (ATBS), whose sorting time on any instance is at least as fast) beats swap-based routing by a constant factor $2/3$. We have the following two theorems, whose proofs can be found in Appendices A and B, respectively.

Theorem 5.1.

The average routing time of any SWAP-based procedure is lower bounded by $n-o\left(n\right)$.

Theorem 5.2.

The average routing time of GDC(TBS) is $2n/3+O\left(n^{\alpha }\right)$ for a constant $\alpha \in \left(\frac{1}{2},1\right)$.

These theorems provide average-case guarantees, yet do not give information about the non-asymptotic behavior. Therefore, we test our algorithms on random permutations for instances of intermediate size.

Our numerics [KSS21] show that Algorithm 4.1 has an average routing time that is well-approximated by $c·n+o\left(n\right)$, where $2/3\lesssim c<1$, using TBS or Adaptive TBS as the binary sorting subroutine, for permutations generated uniformly at random. Similarly, the performance of odd-even sort (OES) is well-approximated by $n+o\left(n\right)$. Furthermore, the advantage of quantum routing is evident even for fairly short paths. We demonstrate this by sampling 1000 permutations uniformly from ${𝒮}_n$ for $n\in [12,512]$, and running OES and GDC(TBS) on each permutation. Due to computational constraints, GDC(ATBS) was run on sample permutations for lengths $n\in [12,206]$. On an Intel i7–6700HQ processor with a clock speed of 2.60 GHz, OES took about 0.04 seconds to implement each permutation of length 512; GDC(TBS) took about 0.3 seconds; and, for permutations of length 200, GDC(ATBS) took about 6 seconds.

The results of our experiments are summarized in Figure 6. We find that the mean normalized time costs for OES, GDC(TBS), and GDC(ATBS) are similar for small $n$, but the latter two decrease steadily as the lengths of the permutations increase while the former steadily increases. Furthermore, the average costs for GDC(TBS) and GDC(ATBS) diverge from that of OES rather quickly, suggesting that GDC(TBS) and GDC(ATBS) perform better on average for somewhat small permutations $(n\approx 50)$ as well as asymptotically.

Figure 6:

The mean routing time and fit of the mean routing time for odd-even sort (OES), and routing algorithms using Tripartite Binary Sort (GDC(TBS)) and Adaptive TBS (GDC (ATBS)). We exhaustively search for $n<12$ and sample 1000 permutations uniformly at random otherwise. We show data for GDC(ATBS) only for $n\le 207$ because it becomes too slow after that point. We find that the fit function ${\mu }_n=an+b\sqrt{n}+c$ fits the data with an $R^2>99.99\mathrm{\%}$ (all three algorithms). For OES, the fit gives $a\approx 0.9999$; for GDC(TBS), $a\approx 0.6599$; and for GDC(ATBS), $a\approx 0.6513$. Similarly, for the standard deviation, we find that the fit function ${\sigma }_n^2=an+b\sqrt{n}+c$ fits the data with $R^2\approx 99\mathrm{\%}$ (all three algorithms), suggesting that the normalized deviation of the performance about mean scales as ${\sigma }_n/n=\mathrm{\Theta }\left(n^{-0.5}\right)$ asymptotically.

The linear coefficient $a$ of the fit of ${\mu }_n$ for OES is $a\approx 0.9999\approx 1$, which is consistent with the asymptotic bound proven in Theorems 5.1 and 5.2. For the fit of the mean time costs for GDC(TBS) and GDC(ATBS), we have $a\approx 0.6599$ and $a\approx 0.6513$ respectively. The numerics suggest that the algorithm routing times agree with our analytics, and are fast for instances of realistic size. For example, at $n=100$, GDC(TBS) and GDC(ATBS) have routing times of $\sim 0.75n$ and $0.72n$, respectively. On the other hand, OES routes in average time $>0.9n$. For larger instances, the speedup approaches the full factor of $2/3$ monotonically. Moreover, the fits of the standard deviations suggest ${\sigma }_n/n=\mathrm{\Theta }(1/\sqrt{n})$ asymptotically, which implies that as permutation length increases, the distribution of routing times gets relatively tighter for all three algorithms. This suggests that the average-case routing time may indeed be representative of typical performance for our algorithms for permutations selected uniformly at random.

6. Conclusion

We have shown that our algorithm, GDC(ATBS) (i.e., Generic Divide-and-Conquer with Adaptive TBS to sort binary strings), uses the fast state reversal primitive to outperform any sWAP-based protocol when routing on the path in the worst and average case. Recent work shows a lower bound on the time to perform a reversal on the path graph of $n/\alpha$, where $\alpha \approx 4.5$ [Bap+20]. Thus we know that the routing time cannot be improved by more than a factor $\alpha$ over SwAPs, even with new techniques for implementing reversals. However, it remains to understand the fastest possible routing time on the path. Clearly, this is also lower bounded by $n/\alpha$. Our work could be improved by addressing the following two open questions: (i) how fast can state reversal be implemented, and (ii) what is the fastest way of implementing a general permutation using state reversal?

We believe that the upper bound in Corollary 4.3 can likely be decreased. For example, in the proof of Lemma 4.1, we use a simple bound to show that the reversal sequence found by GDC(TBS) sorts binary strings with fewer than $cn$ ones sufficiently fast for our purposes. It is possible that this bound can be decreased if we consider the reversal sequence found by GDC(ATBS) instead. Additionally, in the proof of Theorem 4.2, we only consider two pairs of partition points: one pair in each case of the proof. This suggests that the bound in Theorem 4.2 might be decreased if the full power of GDC(ATBS) could be analyzed.

Improving the algorithm itself is also a potential avenue to decrease the upper bound in Corollary 4.3. For example, the generic divide-and-conquer approach in Algorithm 4.1 focused on splitting the path exactly in half and recursing. An obvious improvement would be to create an adaptive version of Algorithm 4.1 in a manner similar to GDC(ATBS) where instead of splitting the path in half, the partition point would be placed in the optimal spot. It is also possible that by going beyond the divide-and-conquer approach, we could find faster reversal sequences and reduce the upper bound even further.

Our algorithm uses reversals to show the first quantum speedup for unitary quantum routing. It would be interesting to find other ways of implementing fast quantum routing that are not necessarily based on reversals. Other primitives for rapidly routing quantum information might be combined with classical strategies to develop fast general-purpose routing algorithms, possibly with an asymptotic scaling advantage. Such primitives might also take advantage of other resources, such as long-range Hamiltonians or the assistance of entanglement and fast classical communication.

A. Average routing time using only SWAPs

In this section, we prove Theorem 5.1. First, define the infinity distance $d_{\mathrm{\infty }}:{𝒮}_n\to \mathbb{N}$ to be $d_{\mathrm{\infty }}\left(\pi \right)={\mathrm{m}\mathrm{a}\mathrm{x}}_{1\le i\le n}\left|{\pi }_i-i\right|$. Note that $0\le d_{\mathrm{\infty }}\left(\pi \right)\le n-1$. Finally, define the set of permutations of length $n$ with infinity distance at most $k$ to be $B_{k,n}=\left\{\pi \in {𝒮}_n:d_{\mathrm{\infty }}\left(\pi \right)\le k\right\}$.

The infinity distance is crucially tied to the performance of odd-even sort, and indeed, any SWAP-based routing algorithm. For any permutation $\pi$ of length $n$, the routing time of any SWAP-based algorithm is bounded below by $d_{\mathrm{\infty }}\left(\pi \right)$, since the element furthest from its destination must be swapped at least $d_{\mathrm{\infty }}\left(\pi \right)$ times, and each of those swAPs must occur sequentially. To show that the average routing time of any SWAP-based protocol is asymptotically at least $n$, we first show that $\left|B_{(1-\epsilon )n,n}\right|/n!\to 0$ for all $0<\epsilon \le 1/2$.

Schwartz and Vontobel [SV17] present an upper bound on $\left|B_{k,n}\right|$ that was proved in [Klø08] and [TS10]:

Lemma A.1.

For all $<r<1$, $\left|B_{rn,n}\right|\le \mathrm{\Phi }(rn,n)$, where

$$\mathrm{\Phi }(k,n)=\left\{\begin{array}{ll}((2k+1)!{)}^{\frac{n-2k}{2k+1}}\prod _{i=k+1}^{2k}(i!{)}^{2/i}& \text{if}0<k/n\le \frac{1}{2}\\ (n!{)}^{\frac{2k+2-n}{n}}\prod _{i=k+1}^{n-1}(i!{)}^{2/i}& \text{if}\frac{1}{2}\le k/n<1.\end{array}\right.$$ (17)

Proof.

Note that $r=k/n$. For the case of $0<r\le 1/2$, refer to [Klø08] for a proof. For the case of $1/2\le r<1$, refer to [TS10] for a proof. □

Lemma A.2.

$$n!=\mathrm{\Theta }\left(\sqrt{n}{\left(\frac{n}{e}\right)}^n\right)$$ (18)

Proof.

This follows from well-known precise bounds for Stirling’s formula:

$$\sqrt{2\pi n}{\left(\frac{n}{e}\right)}^n{e}^{\frac{1}{12n+1}}\le n!\le \sqrt{2\pi n}{\left(\frac{n}{e}\right)}^n{e}^{\frac{1}{12n}}$$ (19)

$$\sqrt{2\pi n}{\left(\frac{n}{e}\right)}^n\le n!\le \sqrt{2\pi n}{\left(\frac{n}{e}\right)}^{n}e$$ (20)

(see for example [Rob55]). □

With Lemmas A.1 and A.2 in hand, we proceed with the following theorem:

Theorem A.3.

For all $<\epsilon \le 1/2$, ${\mathrm{l}\mathrm{i}\mathrm{m}}_{n\to \mathrm{\infty }}\left|B_{(1-\epsilon )n,n}\right|/n!=0$. In other words, the proportion of permutations of length $n$ with infinity distance less than $(1-ϵ)n$ vanishes asymptotically.

Proof.

Lemma A.1 implies that $\left|B_{\left(1-\epsilon \right)n,n}\right|/n!\le \mathrm{\Phi }\left(\right(1-\epsilon )n,n)/n!$. The constraint $0<\epsilon \le 1/2$ stipulates that we are in the regime where $1/2\le r<1$, since $r=1-\epsilon$. Then we use Lemma A.2 to simplify any factorials that appear. Substituting Eq. (17) and simplifying, we have

$$\frac{\text{Φ}\left(\left(1-\epsilon \right)n,n\right)}{n!}=\frac{{\prod }_{i=\left(1-\epsilon \right)n+1}^{n-1}{(i!)}^{2/i}}{{(n!)}^{2\epsilon -2/n}}=O\left(\frac{e^{2\epsilon n-2}}{n^{2\epsilon n-2}}\prod _{i=\left(1-\epsilon \right)n+1}^{n-1}\frac{i^{2+1/i}}{e^2}\right).$$ (21)

We note that $i^{1/i}$ terms can be bounded by

$$\prod _{i=\left(1-\epsilon \right)n+1}^{n-1}{i}^{\frac{1}{i}}\le \prod _{i=\left(1-\epsilon \right)n+1}^{n-1}{n}^{\frac{1}{\left(1-\epsilon \right)n}}\le n^{\frac{\epsilon }{1-\epsilon }}\le n$$ (22)

since $\epsilon \le 1/2$. Now we have

$$O\left(\frac{e^{2\epsilon n-2}}{n^{2\epsilon n-2}}\prod _{i=\left(1-\epsilon \right)n+1}^{n-1}\frac{i^{2+1/i}}{e^2}\right)=O\left(\frac{n}{n^{2\epsilon n-2}}\prod _{i=\left(1-\epsilon \right)n+1}^{n-1}{i}^2\right)$$ (23)

$$=O\left(\frac{n}{n^{2\epsilon n-2}}{\left(\frac{\left(n-1\right)!}{\left(\left(1-\epsilon \right)n+1\right)!}\right)}^2\right)$$ (24)

$$=O\left(\frac{n}{n^{2\epsilon n-2}{e}^{2\epsilon n}}\frac{{(n-1)}^{2n-1}}{{(\left(1-\epsilon \right)n+1)}^{2\left(1-\epsilon \right)n+2}}\right)$$ (25)

$$=O\left(\frac{n}{n^{2\epsilon n-2}{e}^{2\epsilon n}}\frac{n^{2n}}{{(\left(1-\epsilon \right)n)}^{2\left(1-\epsilon \right)n}}\right)$$ (26)

$$=O\left(\frac{n^3}{\text{exp}\left(\left(\text{ln}\left(1-\epsilon \right)\left(1-\epsilon \right)+\epsilon \right)2n\right)}\right).$$ (27)

Since $\mathrm{l}\mathrm{n}(1-\epsilon )(1-\epsilon )+\epsilon >0$ for $\epsilon >0$, this vanishes in the limit of large $n$. □

Now we prove the theorem.

Proof of Theorem 5.1.

Let $\bar{T}$ denote the average routing time of any SWAP-based protocol. Consider a random permutation $\pi$ drawn uniformly from ${𝒮}_n$. Due to Theorem A.3, $\pi$ will belong in $B_{(1-\epsilon )n,n}$ with vanishing probability, for all $0<\epsilon \le 1/2$. Therefore, for any fixed $0<\epsilon \le 1/2$ as $n\to \mathrm{\infty }$, $(1-\epsilon )n<\mathbb{E}\left[d_{\mathrm{\infty }}\left(\pi \right)\right]$. This translates to an average routing time of at least $n-o\left(n\right)$ because we have, asymptotically, $(1-\epsilon )n\le \bar{T}$ for all such $\epsilon$. □

B. Average routing time using TBS

In this section, we prove Theorem 5.2, which characterizes the average-case performance of TBS (Algorithm 4.2). This approach consists of two steps: a recursive call on three equal partitions of the path (of length $n/3$ each), and a merge step involving a single reversal.

We denote the uniform distribution over a set $S$ as $𝒰\left(S\right)$. The set of all $n$-bit strings is denoted ${\mathbb{B}}^n$, where $\mathbb{B}=\{0,1\}$. Similarly, the set of all $n$-bit strings with Hamming weight $k$ is denoted ${\mathbb{B}}_k^n$. For simplicity, assume that $n$ is even. We denote the runtime of TBS on $b\in {\mathbb{B}}^n$ by $T(b)$.

When running GDC(TBS) on a given permutation $\pi$, the input bit string for TBS is $b=I\left(\pi \right)$, where the indicator function $I$ is defined in Eq. (6). We wish to show that, in expectation over all permutations $\pi$, the corresponding bit strings are quick to sort. First, we show that it suffices to consider uniformly random sequences from ${\mathbb{B}}_{n/2}^n$.

Lemma B.1.

If $\pi \sim 𝒰\left({𝒮}_n\right)$, then $I(\pi )\sim 𝒰({\mathbb{B}}_{n/2}^n)$.

Proof.

We use a counting argument. The number of permutations $\pi$ such that $I(\pi )\in {\mathbb{B}}_{n/2}^n$ is $(n/2)!(n/2)!$, since we can freely assign index labels from $\{1,2,\dots ,n/2\}$ to the 0 bits of $I\left(\pi \right)$, and from $\{n/2+1,\dots ,n\}$ to the 1 bits of $I\left(\pi \right)$. Therefore, for a uniformly random $\pi$ and arbitrary $b\in {\mathbb{B}}_{n/2}^n$,

$$\mathrm{P}\mathrm{r}(I(\pi )=b)=\frac{(n/2)!(n/2)!}{n!}=\frac{1}{\left(\begin{array}{c}n\\ n/2\end{array}\right)}=\frac{1}{\left|{\mathbb{B}}_{n/2}^n\right|}.$$ (28)

Therefore, $I(\pi )\sim 𝒰({\mathbb{B}}_{n/2}^n)$. □

While ${\mathbb{B}}_{n/2}^n$ is easier to work with than ${𝒮}_n$, the constraint on the Hamming weight still poses an issue when we try to analyze the runtime recursively. To address this, Lemma B.2 below shows that relaxing from $𝒰({\mathbb{B}}_{n/2}^n)$ to $𝒰\left({\mathbb{B}}^n\right)$ does not affect expectation values significantly.

We give a recursive form for the runtime of TBS. We use the following convention for the substrings of an arbitrary $n$-bit string $a$: if $a$ is divided into 3 segments, we label the segments $a_{0.0},a_{0.1},a_{0.2}$ from left to right. Subsequent thirds are labeled analogously by ternary fractions. For example, the leftmost third of the middle third is denoted $a_{0.10}$, and so on. Then, the runtime of TBS on string $a$ can be bounded by

$$T(a)\le \underset{i\in \{\mathrm{0,1},2\}}{\mathrm{m}\mathrm{a}\mathrm{x}}T\left(a_{0.i}\right)+\frac{n_1\left(a_{0.0}\right)+n_1\stackrel{-}{(a_{0.2})}+n/3+1}{3},$$ (29)

where $\bar{a}$ is the bitwise complement of bit string $a$ and $n_1\left(a\right)$ denotes the Hamming weight of $a$. Logically, the first term on the right-hand side is a recursive call to sort the thirds, while the second term is the time taken to merge the sorted subsequences on the thirds using a reversal. Each term $T\left(a_{0.i}\right)$ can be broken down recursively until all subsequences are of length 1. This yields the general formula

$$T(b)\le \frac{1}{3}\left(\sum _{r=1}^{\lceil {\text{log}}_3\left(n\right)\rceil }\underset{i\in {\{0,1,2\}}^{r-1}}{\text{max}}\left\{n_1\left(a_{0.i0}\right)+n_1\left(\overline{a_{0.i2}}\right)\right\}+n/3^r+1\right),$$ (30)

where $i\in \mathrm{\varnothing }$ indicates the empty string.

Lemma B.2.

Let $a\sim 𝒰\left({\mathbb{B}}^n\right)$ and $b\sim 𝒰({\mathbb{B}}_{n/2}^n)$. Then

$$\mathbb{E}[T(b)]\le \mathbb{E}[T(a)]+\tilde{O}\left(n^{\alpha }\right)$$ (31)

where $\alpha \in \left(\frac{1}{2},1\right)$ is a constant.

The intuition behind this lemma is that by the law of large numbers, the deviation of the Hamming weight from $n/2$ is subleading in $n$, and the TBS runtime does not change significantly if the input string is altered in a subleading number of places.

Proof.

Consider an arbitrary bit string $a$, and apply the following transformation. If $n_1\left(a\right)=k\ge n/2$, then flip $k-n/2$ ones chosen uniformly randomly to zero. If $k<n/2$, flip $n/2-k$ zeros to ones. Call this stochastic function $f\left(a\right)$. Then, for all $a$, $f(a)\in {\mathbb{B}}_{n/2}^n$, and for a random string $a\sim 𝒰\left({\mathbb{B}}^n\right)$, we claim that $f(a)\sim 𝒰({\mathbb{B}}_{n/2}^n)$. In other words, $f$ maps the uniform distribution on ${\mathbb{B}}^n$ to the uniform distribution on ${\mathbb{B}}_{n/2}^n$.

We show this by calculating the probability $\mathrm{P}\mathrm{r}\left(f\right(a)=b)$, for arbitrary $b\in {\mathbb{B}}_{n/2}^n$. A string $a$ can map to $b$ under $f$ only if $a$ and $b$ disagree in the same direction: if, WLOG, $n_1\left(a\right)\ge n_1(b)$, then $a$ must take value 1 wherever $a$, $b$ disagree (and 0 if $n_1\left(a\right)\le n_1(b)$). We denote this property by $a⪰b$. The probability of picking a uniformly random $a$ such that $a⪰b$ with $x$ disagreements between them is $\left(\begin{array}{c}n/2\\ x\end{array}\right)$, since $n_0(b)=n/2$. Next, the probability that $f$ maps $a$ to $b$ is $\left(\begin{array}{c}n/2+x\\ x\end{array}\right)$. Combining these, we have

$$\text{Pr}\left(f\left(a\right)=b\right)=\sum _{x=-n/2}^{n/2}\text{Pr}\left(a\succcurlyeq b\text{and}{n}_1(a)=\frac{n}{2}+x\right)·\text{Pr}\left(f\left(a\right)=b\mid a\succcurlyeq b\text{and}{n}_1\left(a\right)=\frac{n}{2}+x\right),$$ (32)

$$=\sum _{x=-n/2}^{n/2}\frac{\left(\begin{array}{c}n/2\\ \left|x\right|\end{array}\right)}{2^n}·\frac{1}{\left(\begin{array}{c}n/2+\left|x\right|\\ \left|x\right|\end{array}\right)},$$ (33)

$$=\frac{1}{\left(\begin{array}{c}n\\ n/2\end{array}\right)}\sum _{x=-n/2}^{n/2}\frac{\left(\begin{array}{c}n\\ n/2-x\end{array}\right)}{2^n},$$ (34)

$$=\frac{1}{\left(\begin{array}{c}n\\ n/2\end{array}\right)}=\frac{1}{\left|{\mathbb{B}}_{n/2}^n\right|}.$$ (35)

Therefore, $f(a)\sim 𝒰({\mathbb{B}}_{n/2}^n)$. Thus, $f$ allows us to simulate the uniform distribution on ${\mathbb{B}}_{n/2}^n$ starting from the uniform distribution on ${\mathbb{B}}^n$.

Now we bound the runtime of TBS on $f\left(a\right)$ in terms of the runtime on a fixed $a$. Fix some $\alpha \in \left(\frac{1}{2},1\right)$. We know that $n_1\left(f\right(a\left)\right)=n/2$, and suppose $\left|n_1\left(a\right)-n/2\right|\le n^{\alpha }$. Since $f\left(a\right)$ differs from $a$ in at most $n^{\alpha }$ places, then at level $r$ of the TBS recursion (see Eq. (30)), the runtimes of $a$ and $f\left(a\right)$ differ by at most $1/3·\mathrm{m}\mathrm{i}\mathrm{n}\left\{2n/3^r,n^{\alpha }\right\}$. This is because the runtimes can differ by at most two times the length of the subsequence. Therefore, the total runtime difference is bounded by

$$\text{Δ}T\le \frac{1}{3}\sum _{r=1}^{\lceil {\text{log}}_3\left(n\right)\rceil }\text{min}\left\{\frac{2n}{3^r},n^{\alpha }\right\},$$ (36)

$$=\frac{1}{3}\left(\sum _{r=1}^{\lceil {\text{log}}_3\left(2n^{1-\alpha }\right)\rceil }{n}^{\alpha }+2\sum _{r=\lceil {\text{log}}_3\left(2n^{1-\alpha }\right)\rceil +1}^{\lceil {\text{log}}_3\left(n\right)\rceil }\frac{n}{3^r}\right),$$ (37)

$$=\frac{1}{3}\left(n^{\alpha }\text{log}\left(2n^{\alpha }/3\right)+2\sum _{s=0}^{\lfloor {\text{og}}_3\left(n^{\alpha }/2\right)\rfloor -1}{3}^s\right)$$ (38)

$$=\frac{1}{3}\left(n^{\alpha }\mathrm{l}\mathrm{o}\mathrm{g}\left(2n^{\alpha }/3\right)+n^{\alpha }/2-1\right)=\tilde{O}\left(n^{\alpha }\right).$$ (39)

On the other hand, if $\left|n_1\left(a\right)-n/2\right|\ge n^{\alpha }/2$, we simply bound the runtime by that of OES, which is at most $n$.

Now consider $a\sim 𝒰\left({\mathbb{B}}^n\right)$ and $b=f(a)\sim 𝒰({\mathbb{B}}_{n/2}^n)$. Since $n_1(a)$ has the binomial distribution $ℬ(n,1/2)$, where $ℬ(k,p)$ is the sum of $k$ Bernoulli random variables with success probability $p$, the Chernoff bound shows that deviation from the mean is exponentially suppressed, i.e.,

$$\mathrm{P}\mathrm{r}\left(\left|n_1\left(a\right)-n/2\right|\ge n^{\alpha }\right)=\mathrm{e}\mathrm{x}\mathrm{p}\left(-O\left(n^{2\alpha -1}\right)\right).$$ (40)

Therefore, the deviation in the expectation values is bounded by

$$\left|\mathbb{E}\left[T\left(f\left(a\right)\right)\right]-\mathbb{E}\left[T\left(a\right)\right]\right|\le n\mathrm{e}\mathrm{x}\mathrm{p}\left(-O\left(n^{2\alpha -1}\right)\right)+c\left(1-\mathrm{e}\mathrm{x}\mathrm{p}\left(-O\left(n^{2\alpha -1}\right)\right)\right)n^{\alpha }\mathrm{l}\mathrm{o}\mathrm{g}\left(n\right)=\tilde{O}\left(n^{\alpha }\right),$$ (41)

where $c$ is a constant. Finally, we conclude that

$$\mathbb{E}[T(b)]\le \mathbb{E}[T(a)]+\tilde{O}\left(n^{\alpha }\right)$$ (42)

as claimed. □

Next, we prove the main result of this section, namely, that the runtime of GDC(TBS) is $2n/3$ up to additive subleading terms.

Proof of Theorem 5.2.

We first prove properties for sorting a random $n$-bit string $a\sim 𝒰\left({\mathbb{B}}^n\right)$ and then apply this to the problem of sorting $b\sim 𝒰({\mathbb{B}}_{n/2}^n)$ using Lemmas B.1 and B.2.

The expected runtime for TBS can be calculated using the recursive formula in Eq. (30):

$$\mathbb{E}\left[T\left(a\right)\right]\le \frac{1}{3}\left(\sum _{r=1}^{{\text{log}}_3\left(n\right)}\mathbb{E}\left[\underset{i\in {\{0,1,2\}}^{r-1}}{\text{max}}\left\{n_1\left(a_{0.i0}\right)+n_1\left(\overline{a_{0.i2}}\right)\right\}\right]+n/3^r+1\right).$$ (43)

The summand contains an expectation of a maximum over Hamming weights of i.i.d. uniformly random substrings of length $n/3^r$, which is equivalent to a binomial distribution $ℬ\left(n/3^r,1/2\right)$ where we have $n/3^r$ Bernoulli trials with success probability $1/2$. Because of independence, if we sample $X_1,X_2\sim ℬ\left(n/3^r,1/2\right)$, then $X_1+X_2\sim ℬ\left(2n/3^r,1/2\right)$. Using Lemma B.3 with $m=3^{r-1}$, the expected maximum can be bounded by

$$\frac{n}{3^r}+O\left(\sqrt{\left(n/3^r\right)\mathrm{l}\mathrm{o}\mathrm{g}\left(3^{r-1}n/3^r\right)}\right)=\frac{n}{3^r}+\tilde{O}\left(n^{1/2}\right)$$ (44)

since the second term is largest when $r=O(1)$. Therefore,

$$\mathbb{E}\left[T\left(a\right)\right]\le \frac{1}{3}\left(\sum _{r=1}^{{\text{log}}_3\left(n\right)}\frac{2n}{3^r}\right)+\tilde{O}\left(n^{1/2}\right)=\frac{n}{3}+\tilde{O}\left(n^{1/2}\right).$$ (45)

Lemma B.2 then gives $\mathbb{E}[T(b)]\le \frac{n}{3}+\tilde{O}\left(n^{\alpha }\right)$.

The routing algorithm GDC(TBS) proceeds by calling TBS on the full path, and then in parallel on the two disjoint sub-paths of length $n/2$. We show that the distributions of the left and right halves are uniform if the input permutation is sampled uniformly as $\pi \sim 𝒰\left({𝒮}_n\right)$. There exists a bijective mapping $g$ such that $g(\pi )=\left(b,{\pi }_L,{\pi }_R\right)\in {\mathbb{B}}_{n/2}^n\times {𝒮}_{n/2}\times {𝒮}_{n/2}$ for any $\pi \in {𝒮}_n$ since

$$\left|{𝒮}_n\right|=n!=\left(\begin{array}{c}n\\ n/2\end{array}\right)\left(\frac{n}{2}\right)!\left(\frac{n}{2}\right)!=\left|{\mathbb{B}}_{n/2}^n\times {𝒮}_{n/2}\times {𝒮}_{n/2}\right|.$$ (46)

In particular, $g$ can be defined so that $b$ specifies which entries are taken to the first $n/2$ positions—say, without changing the relative ordering of the entries mapped to the first $n/2$ positions or the entries mapped to the last $n/2$ positions—and ${\pi }_L$ and ${\pi }_R$ specify the residual permutations on the first and last $n/2$ positions, respectively. Given $g\left(\pi \right)=\left(b,{\pi }_L,{\pi }_R\right)$, TBS only has access to $b$. After sorting, TBS can only perform deterministic permutations ${\mu }_L(b)$, ${\mu }_R(b)\in {𝒮}_{n/2}$ on the left and right halves, respectively, that depend only on $b$. Thus TBS performs the mappings ${\pi }_L\mapsto {\pi }_L\circ \left({\mu }_L(b)\right)$ and ${\pi }_R\mapsto {\pi }_R\circ \left({\mu }_R(b)\right)$ on the output. Now it is easy to see that when ${\pi }_L,{\pi }_R\sim 𝒰\left({𝒮}_{n/2}\right)$, the output is also uniform because the TBS mapping is independent of the relative permutations on the left and right halves.

More generally, we see that a uniform distribution over permutations $𝒰\left({𝒮}_n\right)$ is mapped to two uniform permutations on the left and right half, respectively. Symbolically, for, $\pi \sim 𝒰\left({𝒮}_n\right)$, we have that

$$g(\pi )=\left(b,{\pi }_L,{\pi }_R\right)\sim 𝒰({\mathbb{B}}_{n/2}^n\times {𝒮}_{n/2}\times {𝒮}_{n/2})=𝒰({\mathbb{B}}_{n/2}^n)\times 𝒰\left({𝒮}_{n/2}\right)\times 𝒰\left({𝒮}_{n/2}\right).$$ (47)

As shown earlier, given uniform distributions over left and right permutations, the output is also uniform. By induction, all permutations in the recursive steps are uniform.

We therefore get a sum of expected TBS runtime on bit strings of lengths $n/3^r$, i.e.,

$$\sum _{r=1}^{{\text{log}}_{2}n}\mathbb{E}\left[T\left(b_r\right)\right]\le \sum _{r=1}^{{\text{log}}_{2}n}\mathbb{E}\left[T\left(a_r\right)\right]+\tilde{O}\left({\left(\frac{n}{2^{r-1}}\right)}^{\alpha }\right)\le \frac{2n}{3}+\tilde{O}\left(n^{\alpha }\right)$$ (48)

where, by Lemma B.1 and the uniformity of permutations in recursive calls, we need only consider $b_r\sim 𝒰({\mathbb{B}}_{n/2^{r-1}}^{n/2^r})$ and we bound the expected runtime using Lemma B.2 with $a_r\sim 𝒰({\mathbb{B}}^{n/2^{r-1}})$. □

We end with a lemma about the order statistics of binomial random variables used in the proof of the main theorem.

Lemma B.3.

Given $m$ i.i.d. samples from the binomial distribution $X_i\sim B(n,p)$ with $i\in \left[m\right]$, and $p\in [0,1]$, the maximum $Y={max}_i.X_i$ satisfies

$$\mathbb{E}\left[Y\right]<pn+O\left(\sqrt{n\mathrm{l}\mathrm{o}\mathrm{g}\left(mn\right)}\right).$$ (49)

Proof.

We use Hoeffding’s inequality for the Bernoulli random variable $X\sim ℬ(n,p)$, which states that

$$\mathrm{P}\mathrm{r}(X\ge (p+ϵ\left)n\right)\le \mathrm{e}\mathrm{x}\mathrm{p}\left(-2n{ϵ}^2\right)\forall \epsilon \ge 0.$$ (50)

Pick $ϵ=\sqrt{\frac{c}{2n}\mathrm{l}\mathrm{o}\mathrm{g}\left(mn\right)}$, where $c>0$ is a constant. For this choice, we have

$$\mathrm{P}\mathrm{r}\left(X_i\ge (p+ϵ)n\right)\le {\left(\frac{1}{mn}\right)}^c$$ (51)

for every $i=1,\dots ,m$. Then the probability that $Y<(p+ϵ)n$ is identical to the probability that $X_i<(p+ϵ)n$ for every $i$, which for i.i.d $X_i$ is given by

$$\mathrm{P}\mathrm{r}(Y<(p+ϵ)n)=\mathrm{P}\mathrm{r}(X<(p+ϵ)n{)}^m>{\left(1-\frac{1}{(mn{)}^c}\right)}^m.$$ (52)

Using Bernoulli’s inequality ($(1+x{)}^r\ge 1+rx$ for $x\ge -1$), we can simplify the above bound to

$$\mathrm{P}\mathrm{r}(Y<(p+ϵ)n{)}^m>1-m^{1-c}{n}^{-c}.$$ (53)

Finally, we bound the expected value of $Y$ by an explicit weighted sum over its range:

$$\mathbb{E}\left[Y\right]=\sum _{k=0}^n\text{Pr}\left(Y=k\right)·k$$ (54)

$$=\sum _{k=0}^{\lfloor \left(p+ϵ\right)n\rfloor }\text{Pr}\left(Y=k\right)·k+\sum _{k=\lfloor \left(p+ϵ\right)n\rfloor +1}^n\text{Pr}\left(Y=k\right)·k$$ (55)

$$\le \sum _{k=0}^{\lfloor \left(p+ϵ\right)n\rfloor }\text{Pr}\left(Y=k\right))·k+n·\sum _{k=\lfloor \left(p+ϵ\right)n\rfloor +1}^n\text{Pr}\left(Y=k\right)$$ (56)

$$\le \sum _{k=0}^{\lfloor \left(p+ϵ\right)n\rfloor }\text{Pr}\left(Y=k\right)·k+{(mn)}^{1-c}$$ (57)

$$\le (p+ϵ)n+(mn{)}^{1-c}.$$ (58)

Since $(mn{)}^{1-c}<1$ for $c>1$,

$$\mathbb{E}[Y]<⌈pn+1+\sqrt{\frac{cn}{2}\mathrm{l}\mathrm{o}\mathrm{g}\left(mn\right)}⌉=pn+O\left(\sqrt{n\mathrm{l}\mathrm{o}\mathrm{g}\left(mn\right)}\right)$$ (59)

as claimed. □