Linear and logarithmic time compositions of quantum many-body operators

TL;DR

This paper introduces new methods for constructing many-body quantum operators efficiently in linear or logarithmic time, significantly improving over existing strategies by using superposition, dynamical decoupling, and ancilla-based parallelization.

Contribution

It presents a generalized framework for fast quantum operator construction, including exact decompositions and protocols that reduce time complexity from linear to logarithmic using ancilla qubits.

Findings

Linear time protocol using superposition and dynamical decoupling

Logarithmic time protocol with ancilla registers and parallel chaining

Significant reductions in time and space complexity for many-body operators

Abstract

We develop a generalized framework for constructing many-body-interaction operations either in linear time, or in logarithmic time with a linear number of ancilla qubits. Exact gate decompositions are given in particular for Pauli strings, many-control Toffoli gates, number-~and parity-conserving interactions, Unitary Coupled Cluster operations, and sparse matrix generators. We provide a linear time protocol that works by creating a superposition of exponentially many different possible operator strings and then uses dynamical decoupling methodology to undo all the unwanted terms. A logarithmic time protocol overcomes the speed limit of the first by using ancilla registers to condition evolution to the support of the desired many-body interaction before using parallel chaining operations to expand the string length. The two techniques improve substantially on current strategies (reductions in time and space can range from linear to exponential), are applicable to different physical interaction mechanisms such as CNOT, $XX$, and $XX+YY$, and generalize to a wide range of many-body operators.

Equations

$$\bar{H}=\{\begin{array}{ll}& {\prod }_{i=1}^n{X}_i\text{(n-qubit Pauli strings)}\\ & ({\prod }_{i=1}^n{P}_i)X_{n+1}\text{(n-controlled X gate)}\\ & {\prod }_{i=1}^{n/2}({\sigma }_{2i-1}^{+}{\sigma }_{2i}^{-}+h.c.)\text{(number/parity consv.)}\\ & ({\prod }_{i=1}^n{\sigma }_i^{+})+h.c.\text{(UCC-type operators,}\\ & \text{sparse matrix generators)},\end{array}$$

$$[\bar{H}{]}^{\alpha }\equiv \exp (-i\alpha \bar{H}),$$

$$U_{i,j}^{†}{R}_i{U}_{i,j}=S_i{R}_j+S_i^{\perp }+S_i{R}_j^{\perp },$$

$$\hat{H}=$$

$$=$$

$$\equiv$$

$$[\bar{H}{]}^{2\alpha }={\left[\hat{H}\right]}^{\alpha }{M}_{n+1}^{†}{\left[\hat{H}\right]}^{-\alpha }{M}_{n+1}.$$

$$C_{\text{tot}}\equiv$$

$$U_{\text{tot}}\equiv$$

$$[\bar{H}{]}^{\alpha }=U_{\text{tot}}^{†}{C}_{\text{tot}}^{†}\left(C[R_1{]}^{\alpha }\right)C_{\text{tot}}{U}_{\text{tot}},$$

$$\hat{H}=$$

$$[\bar{H}{]}^{\alpha }={\left[\prod _{i=1}^{n/2}{R}_{2i-1,2i}\right]}^{\alpha }.$$

$${\hat{H}}_n=$$

$$C_{1,...,n}{Z}_{n+2}=[{\hat{H}}_n{]}^{\pi /2}{M}_{n+1}^{†}[{\hat{H}}_{n-1}{]}^{-\pi /2}{M}_{n+1},$$

$$C_{2,...,n+1}{X}_1=C_{\text{tot}}^{†}(C_{n+1}{X}_1)C_{\text{tot}},$$

$$\text{UCC}(m,n)\equiv \prod _{i=1}^m{\sigma }_i^{+}\prod _{j=m+1}^{m+n}{\sigma }_j^{-}+h.c.$$

$$\hat{H}=$$

$$+i\left(\prod _{i=1}^m{\sigma }_i^{+}\prod _{j=m+1}^{m+n}{\sigma }_j^{-}-h.c.\right)X_{m+n+1}.$$

$$[\bar{H}{]}^{2\alpha }=[\hat{H}{]}^{\alpha }{M}^{†}[\hat{H}{]}^{-\alpha }M=[\text{UCC}(m,n){]}^{2\alpha }.$$

$$U_{i,j}^{†}{R}_i{U}_{i,j}=S_i{R}_j+S_i^{\perp }+S_i{R}_j^{\perp },$$

$${\hat{H}}_n=$$

$$=$$

$${\hat{H}}_{n+1}=$$

$$=$$

$$+\sum _{m=1}^n\left(\prod _{i=1}^{m-1}{S}_i\right)\left(S_m{R}_{m+1}^{\perp }+S_m^{\perp }\right)$$

$$=$$

$$+\sum _{m=1}^n\left(\prod _{i=1}^{m-1}{S}_i\right)\left(S_m{R}_{m+1}^{\perp }+S_m^{\perp }\right)$$

$$=$$

$$[A_i{]}^{\alpha }=P_{\text{ker}\{A_i\}}+\cos (\alpha )P_{\text{supp}\{A_i\}}-i\sin (\alpha )A_i,$$

$$[S_i{B}_j{]}^{\alpha }{R}_i[S_i{B}_j{]}^{-\alpha }=$$

$$+\cos (\alpha )P_{\text{supp}\{B_j\}}{P}_{\text{supp}\{S_i\}}{R}_i{P}_{\text{ker}\{S_i\}}+{\cos }^2(\alpha )P_{\text{supp}\{B_j\}}{P}_{\text{supp}\{S_i\}}{R}_i{P}_{\text{supp}\{S_i\}}$$

$$+{\sin }^2(\alpha )P_{\text{supp}\{B_j\}}{S}_i{R}_i{S}_i+i\sin (\alpha )B_j(S_i{R}_i{P}_{\text{ker}\{S_i\}}-P_{\text{ker}\{S_i\}}{R}_i{S}_i)$$

$$-i\cos (\alpha )\sin (\alpha )B_j(S_i{R}_i{P}_{\text{supp}\{S_i\}}-P_{\text{supp}\{S_i\}}{R}_i{S}_i).$$

$$[S_i{B}_j{]}^{-\alpha }{R}_i[S_i{B}_j{]}^{\alpha }=$$

$$+i\cos (\alpha )\sin (\alpha )B_j[S_i,R_i],$$

$$[X_i{X}_j{]}^{-\frac{\pi }{4}}{Y}_i[X_i{X}_j{]}^{\frac{\pi }{4}}=$$

$$+i\cos (\alpha )\sin (\alpha )(X_i{Y}_i-Y_i{X}_i)X_j$$

$$=$$

Full text

I Introduction

Generating multi-body entanglement is the hallmark of most quantum information technologies. Such technologies promise to harness entanglement across multiple quantum registers to enable potentially significant improvements in speed or precision compared to their classical counterparts. Yet much of the difficulty in the control of quantum systems lies in the constraint that entanglement naturally arises on a local scale while scaling improvements occur as a result of wave functions spread over much larger spaces.

Quantum circuits generating entanglement across $n$ qubits in linear or sub-linear time (circuit depth) in $n$ have been the subject of many studies, with direct use as subroutines in quantum algorithms for factoring Cleve and Watrous (2000); Shor (1999), simulation Lloyd (1996); Harrow et al. (2009); Aspuru-Guzik et al. (2005); Barends et al. (2015); Whitfield et al. (2011); Kassal et al. (2011); Wecker et al. (2014); Babbush et al. (2013); Wiebe et al. (2011); Peruzzo et al. (2013); Dallaire-Demers and Wilhelm (2016); Toloui and Love (2013); Babbush et al. (2016), unstructured search Mølmer et al. (2011); Page et al. (1999), error-correction Crow et al. (2016), and solutions to systems of differential equations Harrow et al. (2009); Berry (2014); Aharonov and Ta-Shma (2003); Wiebe et al. (2011). Much progress has been made for constructing many-body operations, with the most success coming from either finding architectures where commuting two-qubit interactions could be executed simultaneously on overlapping Hilbert spaces, or via cases where a particular many-body gate with known or suspected sublinear implementation can be used to synthesize other many-body circuits. The former has been used for so-called collective Pauli operations on qubits in ion chains Mølmer and Sørensen (1999); Blatt (2000); Monz et al. (2011), while the workhorse for the latter has been the fanout operationMoore and Nilsson (2001); Fenner et al. (2005), which has successfully lead to $O(\log(n))$ depth quantum circuits for various flavours of quantum adders Takahashi and Kunihiro (2008); Gossett (1998); Draper et al. (2004), with related arithmetic operations Van Meter and Itoh (2005); Cleve and Watrous (2000).

Other many-body interactions have also been synthesized to mixed success. The ubiquitous many-control CNOT has found general linear-depth implementations, though with a relatively large prefactor Maslov and Dueck (2003); Barenco et al. (1995); Maslov (2016). Another commonly used gate is defined in terms of the rotation between two arbitrary multi-qubit states, for use in sparse matrix generation Aharonov and Ta-Shma (2003); Wiebe et al. (2011); Berry et al. (2014); Harrow et al. (2009), or, equivalently, pairwise inversion of opposing spins in Unitary Coupled Cluster (UCC) theory Bartlett and Musiał (2007); Taube and Bartlett (2006); Romero et al. (2017); Pulay and Schaefer III (1977); Hoffmann and Simons (1988). Here, suggested implementations have typically involved (based on intended application) either a linear ancilla memory operated on with multi-control rotations Aharonov and Ta-Shma (2003); Wiebe et al. (2011), or Trotter decomposition of the dynamics into (exponentially many) Pauli-string factors but with no ancillas.

In this work, we provide a generic formalism for how to directly compose a wide class of such many-body entangling operations (generated each by an equivalent Hermitian many-body operator $\bar{H}$) via two-(or few-)local interactions, and for which the above discussed protocols and algorithms form important examples of its application. We aim to minimize two standard figures of merit of the generic circuit, namely its depth, defined as the number of layers of gates acting simultaneously on disjoint sets of qubits, and its width, defined as the total number of qubits acted on by the circuit Bera et al. (2010). We find a width-optimized general algorithm, which we label the decoupling protocol, to compose $\bar{H}$ with zero or constant memory overhead and depth limited to linear $n$ scaling. Moreover, we demonstrate a depth-optimized algorithm for simulating $\bar{H}$, the selection protocol, which has logarithmic depth and requires at most linear memory overhead. We demonstrate the formalism towards a linear to exponential speed-up of the aforementioned examples, given in our notation by equivalent Hamiltonians

[TABLE]

where $X_{i}$,$Y_{i}$ and $Z_{i}$ are Pauli operators acting on qubit $i$, $\sigma_{j}^{\pm}=(X_{j}\mp iY_{j})/2$ and projector $P_{i}={\ket{1}}\bra{1}_{i}$. The unitary circuit generated by the many-body composed dynamics can then be written succinctly via the notation

[TABLE]

with $\alpha$ the rotation angle.

In order to identify the type of Hamiltonians we can compose, we first introduce notation and conventions. For simplicity, we disregard local unitary transformations between operators of the same rank. Let $\mathcal{H}=\mathcal{H}_{1}\otimes\mathcal{H}_{2}\otimes\dots\otimes\mathcal{H}_{n}$ denote a separable Hilbert space. Then $R_{i}=\mathds{1}^{\otimes(i-1)}\otimes R\otimes\mathds{1}^{\otimes(n-i)}$, where $\mathds{1}_{j}$ denotes the identity on $\mathcal{H}_{j}$ and $R$ ($\neq\mathds{1}$) is a $2\times 2$-Hermitian matrix for qubits (or $d\times d$ for qudits). We use the convention $\text{rank}(R_{i})\equiv\text{rank}(R)$, thereby ignoring contributions from identities $\bigotimes_{\jmath\neq i}\mathds{1}_{j}$ on other sub-Hilbert spaces. We can write a higher-rank $R_{i}$ as the tensor sum $R=V(S\oplus{S^{\perp}})V^{\dagger}$, where $V$ is any local unitary transformation (i.e. $S^{\perp}$ lies in the kernel of $S$). It is by chaining together the lower-rank $S_{i}$ factors that we will be able to construct our many-body dynamics $\bar{H}$.

II Decoupling protocol

Our main tool is a unitary (two- or few-body) operator $U_{j-1,j}$ which will be used to iteratively increase in length a string of Hermitian operators $S_{1}S_{2}\cdots S_{j}$ acting on the system. However recall that generally $S_{j}$ will not be full rank, and so $U_{j-1,j}$ will invariably have to also act outside the support of $S$. Thus, our protocol will have to execute the desired system dynamics (given by $\bar{H}$) while leaving the rest of the Hilbert space (namely the kernels of $S_{j}$) intact. A condition to using the protocol is that a $U_{i,j}$ can be found such that

[TABLE]

thereby incrementing the length of a string of non-identity Hermitian operators by one when acting on $R_{i}$. Then, successively applying Eq. (2), one can show that the following sum of operator strings of increasing string length can be composed

[TABLE]

as shown in Fig. 1, where $\bar{H}=(\prod_{i=1}^{n}S_{i})R_{n+1}$. Therefore, composing $\bar{H}$ from two-body operators $U_{i,j}$ usually creates unwanted remainder terms $\Sigma_{\text{res}}$. However, the remainder terms commute with $\bar{H}$, while also acting as the identity on the support of $R_{n+1}$. Thus, we can find a one-body unitary transformation $M_{n+1}$ such that it imparts an opposite phase to $R_{n+1}$ (and thus $\bar{H}$), but does not change $\Sigma_{\text{res}}$ mik . The requisite dynamics can then be recovered using the decoupling sequence (cf. Fig. 2)

[TABLE]

Here, to construct an effective Hamiltonian $\bar{H}$ of string-length $n+1$, a total of $4n$ unitary operators $U_{i,j}$ are needed. Note that if $R$ is full rank, Eq. (2) reduces to $U_{i,j}^{\dagger}R_{i}U_{i,j}=R_{i}R_{j}$ and only half as many operators are used, since decoupling is not required.

III Selection Protocol

We now present a composition scheme that can further decrease the required circuit depth for $n$-body operators from a $\mathcal{O}(n)$ to a $\mathcal{O}(\text{log}(n))$ scaling, at the cost of $n-1$ ancillas (cf. Figs. 3 and 4). Without loss of generality we set $n=2^{m}$ where $m\in\mathds{N}$ and introduce two sets of qubit indices, namely register qubits $q_{\text{reg}}=\{1,2,...,n+1\}$ containing the qubits of the desired string and ancilla qubits $q_{\text{anc}}=\{n+2,2,...,2n\}$, where the latter are all initialized to the $\ket{0}$ state.

Moreover, we introduce Toffoli-type unitary operators $C_{i,j}X_{k}$, whereby a NOT is applied to qubit $k$ conditioned on the state of qubits $i,j$ which can either be register or ancilla qubits. The operation can be written mathematically as e.g. $C_{i,j}X_{k}=[S_{i}S_{j}X_{k}]^{\pi/2}$. For $i,j\in q_{\text{reg}}$, $C_{i,j}$ essentially conditions on being in the support of both $S_{i}$ and $S_{j}$. If $i,j\in q_{\text{anc}}$, the operation is a standard Toffoli (or simply letting projector $S_{i}=\ket{1}\bra{1}_{i}$). Note that if $n$ is not a power of $2$, some $C_{i,j}X_{k}$ operations can have both register and ancilla qubits as controls. We define as in Fig. 3 compound operations

[TABLE]

For the boundary case $\text{rank}(S)=1$, we set $U_{\text{tot}}=\mathds{1}$, while if $S$ full rank then $C_{\text{tot}}=\mathds{1}$. All the operations in the brackets can be run parallel. The full selection protocol is given by the sequence

[TABLE]

see Fig. 4. The middle operator is defined as $C[R_{1}]^{\alpha}=[R_{1}]^{\alpha}$ if S full rank, and $[\ket{1}\bra{1}_{2n}R_{1}]^{\alpha}$ otherwise. The result of the sequence is that the many-body rotation is applied only on states that are supported by $R_{1}S_{2}\cdots S_{n}$, while identity is applied otherwise. The selection protocol improves on generic parallelization algorithms by quadratically reducing the space requirements Moore and Nilsson (2001).

The following sections demonstrate how to apply the decoupling and selection protocols to well-known existing problems, to either take advantage of specific two-body interaction mechanisms, or to reduce the time and gate complexity of known implementations. Further details of the derivations are given in Appendix B.

IV Pauli strings

Well known formulas exist for forming strings of Pauli operators in linear time (e.g. Nielsen and Chuang (2002); Casanova et al. (2012)), which we first reproduce using our formalism. Since Pauli operators are full rank, $\hat{H}=S_{1}S_{2}\cdots S_{j}=\bar{H}$ and there is no need for decoupling. The optimal form of $U_{i,j}$ will depend on the architecture and its natural interaction. A standard entangling operation is via $U_{i,j}=\text{CNOT}_{ij}$ gates Nielsen and Chuang (2002), which applied as in Fig. 1 produce a many-body operator (3) with $S_{i}=X_{i}$. However this interaction is neither natural for superconducting nor trapped ion qubits. A native gate for ion-trap designs is the Mølmer-Sørensen gate (MSG), where commuting $U_{i,j}=[X_{i}X_{j}]^{\tfrac{\pi}{4}}$ Mølmer and Sørensen (1999); Sørensen and Mølmer (2000) interactions can be applied simultaneously to all pairs of ions in the chain. We present a third composition with the same gate count as the CNOT and MSG circuits, designed for architectures with exchange gate interactions, $G_{i,j}=\frac{1}{2}(X_{i}X_{j}+Y_{i}Y_{j})$. This is the fastest perfect entangler for most circuit-QED quantum processors Goerz et al. (2016); Siewert et al. (2000), as well as for quantum dot spins coupled by a cavity Imamog et al. (1999) and nuclear spins interacting via a two-dimensional electron gas Mozyrsky et al. (2001). Here, $U_{i,j}=[G_{i,j}]^{-\tfrac{\pi}{2}}$ is an iSWAP gate. Using Eq. (2) and $U_{i,j}^{\dagger}Y_{i}U_{i,j}=Z_{i}X_{i}$ allows us to construct a Pauli-string of length $n$ using $2(n-1)$ iSWAPs. Since the Pauli operators are full rank, one can drastically reduce the depth of the circuit from $\mathcal{O}(n)$ to $\mathcal{O}(\text{log}(n))$ by using Eq. (7), with $\prod_{i=1}^{n}S_{i}=U_{\text{tot}}^{\dagger}R_{1}U_{\text{tot}}$, without needing any ancillary qubits.

Note further that instead of increasing the length of the string using $U_{i,j}$, one can also use the inverse operation to remove a qubit from the string, e.g. to form a disconnected string from a nearest neighbour architecture.

V Number- and parity-conserving strings

We now turn to generating many-body operators that act conditionally only within the fixed excitation-number subspace. These are natural fit for a two-body, exchange gate interaction, $G^{+}_{i,j}=\sigma_{i}^{+}\sigma_{j}^{-}+\sigma_{i}^{-}\sigma_{j}^{+}$, which has the same symmetry, noting also its rank is smaller than $\dim(\mathcal{H}_{i}\otimes\mathcal{H}_{j})$. Defining $F^{-}_{i,j}=-i(\sigma_{i}^{+}\sigma_{j}^{-}-\sigma_{i}^{-}\sigma_{j}^{+})$, we desire strings of $R_{i,j}\in\{G_{i,j},F_{i,j}\}$. We choose $U_{i,k,l}=[Z_{i}G_{k,l}]^{\tfrac{\pi}{4}}$ as the (now three-qubit) entangling operation, giving $U_{i,k,l}^{\dagger}G_{i,j}U_{i,k,l}=F_{i,j}G_{k,l}+G_{i,j}P_{\text{ker}\{G_{k,l}\}}$, where $R_{k,l}^{\perp}=\tfrac{1}{2}(\mathds{1}+Z_{k}Z_{l})$. Following the steps in Eq. (3), one obtains

[TABLE]

a many-body Hamiltonian that collectively excites and de-excites $n$ qubits in a number-conserving way. By choosing $M_{n}=[Z_{n}]^{\tfrac{\pi}{2}}$ one can apply the decoupling sequence (4) to pick out one particular number-conserving string

[TABLE]

More generally, one may desire an entangler that conserves parity, without conserving numberDallaire-Demers and Wilhelm (2016). This can be achieved by applying local operations ($X_{i}$) to transform operators in the string from $G_{i,j}$ to $\sigma_{i}^{+}\sigma_{j}^{+}+\sigma_{i}^{-}\sigma_{j}^{-}$. As we detail in Appendix B, the whole sequence takes $2n-4$ $U_{i,j,k}$ gates, or equivalently $6n-10$ iSWAPs. Half as many are required if $\hat{H}$ is used instead. Alternatively, the many-body dynamics can be generated with the selection protocol at the cost of $n-1$ ancillas. For this, we can reuse $U_{i,j,k}=C_{i,j}X_{k}$ for $i,j\in q_{\text{reg}}$. This total sequence uses a total of $2n-4$ entanglers $U_{i,k,l}$ and $n+4$ Toffolis in a circuit depth of $4\log(n)+3$.

VI Multi-control CNOT gates

$C_{1,...,n}X_{n+1}$ gates have widespread use in quantum and reversible computation, including for circuit distillation Maslov et al. (2007), unstructured search Mølmer et al. (2011), factorization Cleve and Watrous (2000), error-correction Crow et al. (2016), and linear equations system solvers Aharonov and Ta-Shma (2003). For our constructions, let $U_{i,j,k}=[P_{i}X_{j}P_{k}]^{\tfrac{\pi}{2}}$ (a Toffoli gate with a relative phase Maslov (2016), though a regular Toffoli can also be used) act on three qubits, recalling that $P_{i}=\ket{1}\bra{1}_{i}$. The chaining operation is given by $U_{i,j,k}Z_{i}Z_{j}U_{i,j,k}^{\dagger}=-P_{i}Z_{j}Z_{k}+P_{i}^{\perp}Z_{j}$, with $P_{i}^{\perp}=\ket{0}\bra{0}_{i}$. Repeated application of the chaining operation on $R_{1,2}=Z_{1}Z_{2}$ following Eq. (3) (see Appendix B) gives

[TABLE]

Choosing $M=[X]^{\tfrac{\pi}{2}}$, one can use the decoupling protocol (4) to obtain a multi-qubit-controlled rotation around an arbitrary angle. For a phaseless multi-control CNOT gate, one can compose instead the sequence

[TABLE]

using $4n-2$ Toffolis, or equivalently $16n-8$ CNOT gates. This cuts in half the size and depth of the longstanding construction proposed by Barenco et al. (1995); Maslov and Dueck (2003); Maslov (2016).

A more drastic reduction results from the selection protocol, where $S_{i}=P_{i}$ and thus $\text{rank(S)}=1$. Eq. (7) simplifies to

[TABLE]

resulting in an $n$-control CNOT gate using $2(n-1)$ Toffoli gates and $2\log(n)$ depth (cf. Fig. 4). This gives exponential parallelization compared to the $O(n)$ ancilla solution found in Maslov (2016).

VII Unitary coupled cluster

Another many-body operator which is frequently used (e.g. in quantum chemistry algorithms for computing energy landscapes), is an operator which transfers population between electronic orbitals (encoded in the qubits) while maintaining electron number and spin. More generally, when the operator couples arbitrary many-qubit states, it corresponds to a sparse matrix off-diagonal element Aharonov and Ta-Shma (2003). It takes the form

[TABLE]

We have seen in the section on Pauli strings how to construct $R=\prod_{i=1}^{m+n}X_{i}$ using $2(m+n-1)$ entanglers. Since $\prod_{i=1}^{n+m}X_{i}$ contains all $2^{m+n}$ combinations of products of $\sigma^{+}$ and $\sigma^{-}$, we use $U=[(\prod_{i=1}^{m}P_{i})(\prod_{j=m+1}^{n}P_{j}^{\perp})X_{n+m+1}]^{\tfrac{\pi}{2}}$, which we know how to construct from the previous section on multi-control CNOTs, computing $\hat{H}=U^{\dagger}RU$ to get

[TABLE]

By setting $M=[Z_{m+n+1}]^{\tfrac{\pi}{2}}$ we can apply the decoupling protocol to construct the unitary dynamics of the $\text{UCC}(m,n)$ operator in a circuit with $m+n+1$ qubits ($q_{m+n+1}$ is an ancillary qubit) using $4(m+n-1)$ iSWAPs and $4(m+n)$ (relative phase) Toffolis,

[TABLE]

Conventional factorization of the $\text{UCC}(m,n)$ terms into Pauli strings scales exponentially as $\mathcal{O}(2^{m+n-1})$ in the number of two-qubit gates cost whereas only $36(m+n)+\mathcal{O}(1)$ iSWAPs are required when using our decoupling protocol. Even further decrease in composition time is once again achieved if the Pauli string and multi-CNOT gates are produced using the selection protocol, down to a depth of $O(\log n)$.

VIII Architectural considerations

Clearly any time and space complexity advantages will be subject to limitations set by architecture. The presence of $O(n)$ ancillas (needed for the selection protocol) is actually fairly easy to include, as most architectures have ancillary electronic, motional or photon bus degrees of freedom. Despite much worse lifetimes typically found in these states, the (linear) tradeoff in error rate is more than made up by an exponential speedup in time and justifies their use for many-body gates, in particular when memory operations are expensive. Note previous generic $O(\log(n))$ circuit constructions require $O(n^{2})$ space Moore and Nilsson (2001), which may make implementation impractical. The adjacency graph of bodies that couple to each other in the architecture will also greatly impact composition time. For many-body operators spanning much of the graph, the spanning tree depth will determine how many steps it will take to link distant qubits in the collective many-body operator (intermediary unneeded qubits can be removed in the subsequent step). Thus, we expect the circuit depth will scale as $O(\log(n))$ when the depth of the spanning tree is $O(\log(n))$, as in Brennen et al. (2003); Meter and Oskin (2006); Kimble (2008); Hall et al. (2015); Van Meter et al. (2006); Beigi et al. (2011); Thaker et al. (2006), and $O(\sqrt[d]{n})$ scaling for $d$-dimensional, nearest-neighbour architectures being expected Choi and Van Meter (2011, 2012); Kaicher et al. .

IX Conclusions

We have developed two protocols, the decoupling and selection compositions, to generate many-body operators in $O(n)$ time for zero or constant memory overhead, and $O(\log(n))$ time for $O(n)$ ancillas, respectively. The former enhances previous constant-overhead approaches, with improvement ranging for prominent examples from linear (factor of 2 for multi-control CNOTs) to exponential (UCC). Our construction to bring down further the runtime to $O(\log(n))$ depth also improves quadratically on the space requirements of previous generic methods. Our approach is generated directly from Hamiltonian dynamics, allowing straightforward incorporation of different coupling mechanisms and architectures.

Acknowledgements.

This work was supported by the European union through ScaleQIT and by US ARL-CDQI program through cooperative agreement W911NF-15-2-0061. The authors wish to thank Pierre-Luc Dallaire-Demers, Nathan Wiebe and Ryan Babbush for helpful discussions.

Appendix A Proof for decoupling protocol

Though the decoupling protocol could be applicable to a wide range of entangling operations, we will be looking at the specific case whereby a unitary operator $U_{i,j}$ acts on some Hermitian operator $R_{i}$ via

[TABLE]

stressing that the entangler’s action is chosen such that it covers the example cases as well as the prerequisite of the selection protocol. We will now prove the result of the staircase circuit of Fig. 2 from the main text,

[TABLE]

where we set $\hat{H}=\hat{H}_{n}$ to clearly indicate that Eq. $\eqref{h2}$ is the result after $n$ entanglers in the staircase. We assume Eq. (17) holds for some fixed $n\in\mathds{N}$. Then, using Eq. (16) gives

[TABLE]

therefore, Eq. (17) must hold for all $n\in\mathds{N}$.

Appendix B Gate derivations

In the following examples we will use the modified Euler identity

[TABLE]

where $A_{i}$ is a Hermitian operator that squares to the identity on its support, i.e. $A_{i}^{2}=P_{\text{supp}\{A_{i}\}}$, and projector $P_{\text{ker}\{A_{i}\}}$ is the identity operator on the kernel of $A_{i}$. Moving to tensor products of such operators, e.g. $S_{i}$ and $B_{j}$, we have

[TABLE]

B.1 Pauli string generation by XX gates

For Mølmer-Sørensen composition Mølmer and Sørensen (1999) we have $S_{i}=X_{i}$ and $B_{j}=X_{j}$ and since Pauli-operators have full rank, $P_{\text{supp}\{S_{i}\}}=\mathds{1}_{i}$ and $P_{\text{supp}\{B_{j}\}}=\mathds{1}_{j}$. Setting $R_{i}=Y_{i}$ and $\alpha=\pi/4$, Eq. (20) reduces to

[TABLE]

which, using the group properties of Pauli operators $[X,Y]=2iZ$, gives

[TABLE]

B.2 Pauli string generation by CNOT gates

For CNOT gates, one can increment the string length by one by sandwiching a single Pauli-$Z$ operator in between two CNOTs Nielsen and Chuang (2002),

[TABLE]

B.3 Pauli string generation by iSWAP gates

We now consider the flip-flop interaction as the generator, where $U_{i,k}=[\sigma_{i}^{+}\sigma_{j}^{-}+\sigma_{i}^{-}\sigma_{j}^{+}]^{\alpha}$. For an iSWAP operation we have $\alpha=\pi/2$, and if acting on $R_{i}=X_{i}$ we get

[TABLE]

B.4 Number conserving strings by iSWAP gates

For composing number-conserving strings we have $U_{i,k,l}=[Z_{i}G_{kl}]^{\tfrac{\pi}{4}}$, with $G_{i,j}=\sigma_{i}^{+}\sigma_{j}^{-}+\sigma_{i}^{-}\sigma_{j}^{+}$, $F_{i,j}=-i(\sigma_{i}^{+}\sigma_{j}^{-}-\sigma_{i}^{-}\sigma_{j}^{+})$, $P_{\text{ker}\{G_{k,l}\}}=\frac{1}{2}(\mathds{1}+Z_{k}Z_{l})$ and $P_{\text{supp}\{G_{k,l}\}}=\frac{1}{2}(\mathds{1}-Z_{k}Z_{l})$. Applying Eq. (20) with $S=Z_{i}$,$B=G_{k,l}$ and $R=G_{i,j}$ we get

[TABLE]

since $Z_{i}G_{i,j}=-iF_{i,j}$. One can similarly show that $U_{i,k,l}F_{i,j}U_{i,k,l}^{\dagger}=F_{i,j}P_{G_{k,l}^{\perp}}+G_{i,j}G_{k,l}$. The generator $Z_{i}G_{k,l}$ can be obtained from iSWAPs through $[F_{i,l}]^{-\pi/2}[G_{i,k}]^{\alpha}[F_{i,l}]^{\pi/2}=[Z_{i}G_{k,l}]^{\alpha}$.

For simplicity, we let $n$ be even. We have

[TABLE]

Note that $P_{\text{ker}\{G_{3,4}\}}$ commutes with the next entangler of the staircase circuit of Fig. 2 in the main letter, yielding

[TABLE]

Clearly, we after the $n/2$-th entangler we get

[TABLE]

The proof for the above equation is analogue to the one before, when we proved Eq. (3). In terms of our more loose notation where local unitary transformations are ignored, Eq. (26) is equivalent to $U_{i,k,l}R_{i,j}U_{i,k,l}^{\dagger}=R_{i,j}R_{k,l}+R_{i,j}R_{k,l}^{\perp}$ while Eq. (28) may be written as

[TABLE]

B.5 Multi-control NOT gates via Toffoli gates

For generating multi-control NOT gates, we have $U_{i,j,k}=[P_{i}X_{j}P_{k}]^{\tfrac{\pi}{2}}$ with $P_{i}=\ket{1}\bra{1}_{i}$. Note that one can just as well use a regular Toffoli for $U_{i,j,k}$ though typically the construction uses more gates than its relative phase version Maslov (2016). Plugging into Eq. (20), with $S=P_{i}X_{j}$, $B=P_{k}$ and $R=Z_{i}Z_{j}$ we obtain

[TABLE]

where we used, that $P_{\text{supp}\{S\}}=P_{i}$, $P_{\text{ker}\{S\}}=P_{i}^{\perp}$, $P_{\text{supp}\{B\}}=P_{k}$, $P_{\text{ker}\{B\}}=P_{k}^{\perp}$, $P_{\text{supp}\{R\}}=\mathds{1}$ and $P_{\text{ker}\{R\}}=0$. Eq. (10) in the main text arises as follows: In the first iteration, we have

[TABLE]

Since $U_{2,3,4}$ commutes with $P_{1}^{\perp}Z_{2}$ we get

[TABLE]

in the next step. Assume that for a fixed $n\in\mathds{N}$ the staircase circuit yields

[TABLE]

Then, we use Eq. (B.5) to compute the $n+1$-th step,

[TABLE]

therefore Eq. (31) holds for all $n\in\mathds{N}$. At this point either the usual mirroring pulse can be used to decouple unwanted terms, or, as mentioned in the main text, a full rotation on the last qubit Barenco et al. (1995) (here, the qubit with the highest index) can be used to remove the unwanted phase and generate a phase-less multi-control Toffoli.