On the robustness of bucket brigade quantum RAM

A random access memory (RAM) is a device that stores information in an array of memory cells in the form of bits. In contrast to other types of information storage devices, the access latency to any memory cell is constant and does not depend on the location of the information in the RAM. Information stored in the RAM is retrieved by inputting the address of the desired memory cell in a routing circuit. Any address in a RAM with $N={2}^{n}$ memory cells can by addressed via a unique n bit input query string. The corresponding output register contains the contents of the addressed memory location.

The typical physical implementation of the addressing mechanism uses the fanout architecture [1, 2], in which the routing scheme corresponds to a binary tree. Each node consists of a pair of transistors which routes the electronic signal down one of the two paths to the subsequent level. In the fanout architecture, a given level has all nodes sharing the same routing direction (left or right), set by the corresponding address bit. An n bit query string determines a unique path in the binary tree, corresponding to the desired memory location. In the process, ${\mathcal{O}}({2}^{n})$ transistors are activated.

Alternative routing schemes with ${\mathcal{O}}(\mathrm{poly}(n))$ activated transistors have been proposed, corresponding to exponentially lower energy consumption. One such example is the 'bucket brigade' scheme [3, 4]. However, most of the classical implementations follow the simpler fanout architecture, as the power consumption of RAM is negligible in comparison with the power consumption of other components in the architecture.

The classical RAM addressing scheme can be generalized to a quantum RAM (which we simply call qRAM from here on) scheme, where the input is a quantum state, the routing components are inherently quantum, and the information stored can be either classical, i.e. $| 0\rangle$ or $| 1\rangle$ but not a superposition of both, or quantum, i.e. any arbitrary superposition of $| 0\rangle$ and $| 1\rangle .$ In the present paper we consider qRAM that stores only classical information. Such memory allows querying superposition of addresses

$$\begin{eqnarray}&&\displaystyle \sum _{j}\;{\alpha }_{j}| j\rangle | 0\rangle \overset{\mathrm{qRAM}}{\longrightarrow }\displaystyle \sum _{j}\;{\alpha }_{j}| j\rangle | {m}_{j}\rangle ,\end{eqnarray} \tag{ 1 }$$

where ${\displaystyle \sum }_{j}{\alpha }_{j}| j\rangle$ is a superposition of queried addresses and $| {m}_{j}\rangle$ represents the content of the jth memory location. A memory that stores classical information but allows queries in superposition is required for quantum algorithms such as Grover's search on a classical database [5], collision finding [6], element distinctness [7], dihedral hidden subgroup problem [8], quantum matrix inversion [9, 10], quantum machine learning [11–14]and various practical applications mentioned in [15]. In fact, such a quantum memory plays the role of the oracle and is ideal in implementing any oracle-based quantum algorithm, in which the oracle is used to query classical data in superposition. It is important to distinguish between algorithms such as quantum matrix inversion [9, 10] or quantum machine learning [11–14] that only require a number of queries polynomial in n, and those such as quantum searching [5] that require a number of queries super-polynomial in n. In the former case, as will be seen, the maximum qRAM gate error rate tolerated by the algorithms scales polynomially in n, and qRAM quantum error correction may not be required. In the latter case, which is the one that we concentrate on in this paper, the maximum tolerable qRAM error rate scales super-polynomially in n and quantum error correction is needed.

A conceptually simple physical implementation of a qRAM corresponds to a direct generalization of the fanout architecture used in classical RAMs. However, the number of faulty components that can be tolerated by the quantum architecture is of prime importance due to the difficulty in maintaining quantum coherence. This motivates searching for schemes with fewer faulty components. A fundamental assumption of the qRAM architecture is that 'active' gates¹¹ are the only ones with significant errors.

In this paper we investigate the bucket brigade qRAM proposal introduced in [3, 4]. Assuming one requires a constant error probability for the oracle query, then with the bucket brigade error model it suffices to have an error rate that is on the order of ${\mathcal{O}}(1/{n}^{2}).$ In the bucket brigade model, one assumes that each computational path only contains ${\mathcal{O}}(n)$ components that are faulty, and that a total of ${\mathcal{O}}({n}^{2})$ faulty operations are performed. One can argue that it is optimistic to assume that the so-called 'non-active' components will be completely error-free. And, one could counter-argue that the error rates will be much lower, and thus ignored for problem instances of appropriate size. For the purposes of this article, we set aside these concerns and accept the premise of there only being ${\mathcal{O}}(n)$ faulty components.

In contrast to such a qRAM, if one just used a regular fanout circuit for the lookup, with no error correction, one would need to maintain quantum coherence over an exponential number of components [4]. In order to achieve a constant error rate for the query in this case, one would need to implement a fault-tolerant version of the look-up circuit, which would normally incur an overhead that is polynomial in n. One advantage of bucket brigade qRAM is thus to bypass the poly-log overhead of fault tolerant quantum error correction needed to achieve a constant error rate for a look-up. Such an error rate would be sufficient if the qRAM is used in an algorithm making a constant number of queries, for example, for certain state generation algorithms [16, 17]. In general, for an algorithm with inverse polynomially many queries, it would suffice to reduce the query error rate to be inverse polynomial in n, e.g. [11, 18].

In this article, we firstly shed doubt on the usefulness of a qRAM that provides queries with constant probability of error, when used with algorithms such as quantum searching that make super-polynomially many oracle queries. As an aside, we note that if the imperfect query operation is assumed to be unitary, and if one can apply the inverse of this imperfect query, then one can apply simple amplification methods to achieve queries with arbitrarily small error δ using a number of repetitions that is proportional to $\mathrm{log}(1/\delta ).$ It was shown that this logarithmic overhead is not necessary for quantum searching [19] and other problems [20]. However, there is no reason to expect the errors in a realistic qRAM to behave this way, and in this article we consider incoherent errors.

We first show that a very simple model of incoherent physical errors induces an overall query error similar to the one described by Regev and Schiff [21]. Consequently, a qRAM that produces queries with constant error will not permit the quadratic speed-up in Grover's search algorithm [5] or any other quantum search algorithm one might design. We show that one cannot escape achieving an error rate that is super-polynomially small. We conjecture that this error model nullifies the asymptotic speed-ups of other quantum query algorithms as well, and leave as open questions the extension of this result to other important query problems.

This negative result implies the need for some means of error reduction for the qRAM, with a look-up error rate exponential in n. For consistency we assume a physical error rate that is inverse polynomial in n, the logarithm of the size of the database. We thus explore a natural approach, using quantum error correcting codes (QECCs), to provide this error reduction, and argue that the apparent advantage of qRAM disappears in this case; in principle, one can make the error rate arbitrarily small, however the advantage of a small number of activated gates in the bucket brigade architecture appears to be lost when active error correction has to be performed on each gate. The main motivation for the quantum bucket brigade approach over a straightforward binary-tree approach is that the equivalent of the active gates are the only gates prone to error, and thus an inverse polynomial in n error rate suffices in order to achieve an overall constant error per qRAM look-up.

The remainder of this paper is organized as follows. In section 2 we describe the bucket brigade qRAM architecture and prove that for the Regev and Schiff model [21] the error rate per gate must scale as inverse polynomial in the size of the database. In section 3 we develop and analyze a simple error model that provides intuition for the overall behavior of the memory with realistic noisy environments. In section 4, in order to discuss approaches for introducing quantum error correction inside the qRAM architecture, we introduce a circuit model for the bucket brigade architecture. We then argue in section 5 that a fault-tolerant bucket brigade qRAM loses the advantage of small number of active components. Finally, in section 6 we conclude and present some open problems and directions for future research.

In [3, 4], Giovanetti et al proposed a quantum bucket brigade addressing scheme requiring only ${\mathcal{O}}(n)$ activations per memory call. The nodes of the routing binary tree are three level quantum systems (qutrits), with an energy spectrum schematically depicted in figure 1.

Zoom In Zoom Out Reset image size

The ${2}^{n}$ qutrits at the nodes of the binary tree are initially prepared in the ground state $| \bullet \rangle ,$ named the 'wait' state, and the memory address is specified by the n-qubit state $| {a}_{0}{a}_{1}\ldots {a}_{n-1}\rangle .$ At time t₀, the address qubit $| {a}_{0}\rangle$ is input at the root of the tree and it interacts with the qutrit at node 0 changing its state from $| \bullet \rangle$ to $| {a}_{0}\rangle .$ The states $\{| 0\rangle ,| 1\rangle \}$ of the node qutrit are coupled to two spatial directions (paths), right and left respectively. The role of the coupling is to route the following incoming address photon along the correct path of the binary routing tree. At time t₁, the subsequent address qubit $| {a}_{1}\rangle$ is input at the root of the tree. The address qubit $| {a}_{1}\rangle$ interacts with the qutrit at node 0 and is physically routed down the left or right path of the tree depending upon the state $| {a}_{0}\rangle$ of node 0. Consequently it changes the state of the corresponding node at level 1 to $| {a}_{1}\rangle .$ The process continues until all the remaining address qubits are sent through the tree, with the kth address qubit changing the state of the node at the kth level from $| \bullet \rangle$ to $| {a}_{k}\rangle .$ After ${\mathcal{O}}({n}^{2})$ time steps¹² , a routing path is assigned from the root of the tree to the desired memory location, with only n nodes in the path (one node per level) having a state different from $| \bullet \rangle .$ A bucket brigade routing scheme for an 2³-address qRAM is schematically depicted in figure 2. The proposed physical implementation of bucket brigade in [4] uses atoms in a cavity as routing nodes and polarization photon states as addressing qubits.

Zoom In Zoom Out Reset image size

In [4], the authors claim that the bucket brigade scheme is coherent as long as the error per gate, scales as ${\mathcal{O}}(1/{n}^{2}).$ For this error scaling, as n increases, the overall error rate of the qRAM oracle asymptotically approaches a constant. Although constant or polynomial error rates suffice for some quantum algorithms [11, 18], such error rates are not favorable for some other important quantum algorithms. For example, Regev and Schiff [21] showed that the quadratic speed-up in Grover's searching algorithm vanishes when using oracles with a constant error rate. Namely, in order to regain the quadratic speed-up, the error rate per oracle call should scale no worse than ${\mathcal{O}}({2}^{-n/2})$ (therefore the error rate not only needs to be non-constant but it must vanish at a fast enough rate with increasing n).

In the next few sections, we construct a simple model of bucket brigade qRAM with errors and show in appendix A that Regev and Schiff error model [21] resembles the model we construct. Based on this resemblance and assuming ${\mathcal{O}}({n}^{2})$ faulty operations per memory call, we conjecture that in order to implement the qRAM for quantum searching, the overall error rate per memory call has to be in ${\mathcal{O}}({2}^{-n/2}).$ In fact, for this to hold, the error rate per gate should decrease faster than $1/f(n),$ where $f(n)\in \omega ({2}^{n/2}).$ Thus has to be in $o({2}^{-n/2})$ and hence much smaller than ${\mathcal{O}}(1/{n}^{2}),$ since the overall error rate per memory call must scale as

$$\begin{eqnarray}&&1-{\left(1-\displaystyle \frac{1}{f(n)}\right)}^{{\mathcal{O}}({n}^{2})}\in {\rm{\Omega }}\left(\displaystyle \frac{{n}^{2}}{f(n)}\right),\end{eqnarray} \tag{ 2 }$$

and in order to satisfy

$$\begin{eqnarray}&&1-{\left(1-\displaystyle \frac{1}{f(n)}\right)}^{{\mathcal{O}}({n}^{2})}\in {\mathcal{O}}({2}^{-n/2}),\end{eqnarray} \tag{ 3 }$$

it is required that

$$\begin{eqnarray}f(n)\in {\rm{\Omega }}\left({n}^{2}{2}^{n/2}\right)\; & \Longrightarrow & \;\displaystyle \frac{1}{f(n)}\in {\mathcal{O}}\left(\displaystyle \frac{1}{{n}^{2}{2}^{n/2}}\right)\\ & \Longrightarrow & \varepsilon \in o({2}^{-n/2}).\end{eqnarray} \tag{ 4 }$$

Recently Hong et al [22] proposed a bucket brigade qRAM scheme in which the number of time steps required per memory call is reduced from ${\mathcal{O}}({n}^{2})$ to ${\mathcal{O}}(n).$ While this reduction decreases the overall error rate, the error rate per gate must still be in $o({2}^{-n/2}).$

The need for super-polynomially small (in n) error rate per gate for real world applications motivates a more thorough analysis of the bucket brigade qRAM scheme and the need for quantum error correction, these topics being the subject of the following sections.

In this section we introduce a simple toy error model for the physical implementation proposed in [4], in which the qutrits are implemented by trapped atoms in cavities. The address qubits are implemented by photons that propagate along the network of cavities, and excite the corresponding qutrit to either of the states $| 0\rangle$ or $| 1\rangle ,$ depending on their polarization. In this way, the incoming address photons create a 'path' through the binary tree of cavities, leading to the desired memory location. The readout is performed by injecting a 'bus' qubit (photon) at the root of the tree that interacts with the desired memory location, copies its value (the states stored by the memory are $| 0\rangle$ or $| 1\rangle ,$ and not any superposition), and finally is sent back along the routing tree exiting through the root with the corresponding memory location content. For more details about the physical model an interested reader is referred to [4].

3.1. Toy error model

In the following we assume that the only source of errors in the above model is due to random flips between the states $| 0\rangle$ and $| 1\rangle$ of the qutrit. We assume a typical symmetric bit-flip error, in which at each time step the state $| j\rangle$ can either flip to $| j\oplus 1\rangle$ with probability or remain unchanged with probability $1-\varepsilon .$ The motivation for considering this error model is that, since the states $\{| 0\rangle ,| 1\rangle \}$ are close together in the energy spectrum, significantly less energy is required to cause a flip between them, hence such flips are more likely to occur. In reality, there may be other sources of errors such as coupling errors, decaying of excited qutrit states to the ground state, loss of photons during the routing process and so on. However, our toy model illustrates the effects of an error that would naturally occur in a realistic physical realization of a qRAM. There is no reason to expect these other sources of errors would help matters (otherwise, one could seek to deliberately introduce or simulate such errors).

It is not hard to observe that any error in the routing process can propagate through the tree resulting in various possibilities. Considering all possible errors in such a model, the possible paths that the bus photon could take in the final step termed as right path, wrong path and no-path, respectively. For convenience, we further assume the operations used to un-compute the path information encoded in the qRAM are error-free.

(1) Right path—this scenario occurs when no flips (errors) arise during the routing process. In this ideal scenario, the bus reaches the correct location in the qram as specified by the input address. Figure 2 depicts an example of a right path given an input address $| 010\rangle .$

To compute the probability p_rp of such an event, we require that no bit flip occurs at each of the j levels. Taking the intersection of such events for all $n-1$ levels of the binary tree gives the probability of the right path

$$\begin{eqnarray}{p}_{\mathrm{rp}} & = & \displaystyle \prod _{j=0}^{n-1}{(1-\varepsilon )}^{n-j}={(1-\varepsilon )}^{\displaystyle \sum _{j=0}^{n-1}(n-j)}\\ & = & {(1-\varepsilon )}^{n(n+1)/2}.\end{eqnarray} \tag{ 5 }$$

(2) Wrong path—this error refers to the cases wherein the the bus reaches any other location in the qRAM other than the location corresponding to the input address. A wrong path error occurs at level i if the state $| j\rangle$ of the active routing qutrit at level i flips to $| j\oplus 1\rangle$ and no other errors occur subsequently (at later time steps). The scenario where another error occurs at a later time step in the levels preceding to the jth level leads to a no-path error which we discuss later. The following two figures illustrate two possible wrong paths for the input address $| 010\rangle .$ In figure 3, the error is assumed to occur in the third time step, due to which the bus accesses the wrong location corresponding to $| 011\rangle .$ In figure 4, the error is assumed to occur in the second time step, with the bus wrongly accessing the location corresponding to $| 000\rangle .$

Zoom In Zoom Out Reset image size

Zoom In Zoom Out Reset image size

In order to calculate the probability of a wrong path occurring, we consider the probability of any path occurring, regardless of whether it is the right or wrong path, we denote this probability by p_path. Suppose the state $| {\psi }_{j}\rangle$ is being routed down the qRAM circuit to the jth level. If any of the $(j-2)$ first routing nodes have flipped then the state will be routed down an unexpected branch and will not excite the jth level of the tree, resulting in a no-path. The probability of success at this given time step is therefore ${(1-\varepsilon )}^{j-1},$ where  is the probability of a node flipping, recall we must include the level-0 root node here. This can only for levels 2 and above. The overall probability of success is therefore the product of each of the individual probabilities of success at each time step (including the time step to send the bus qubit down the tree to recover the information stored in the RAM). This probability is given by:

$$\begin{eqnarray}{p}_{\mathrm{path}} & = & {p}_{\mathrm{wp}}+{p}_{\mathrm{rp}}=\displaystyle \prod _{j=2}^{n}{(1-\varepsilon )}^{j-1}\\ & = & {(1-\varepsilon )}^{\displaystyle \sum _{j=2}^{n}(j-1)}={(1-\varepsilon )}^{n(n-1)/2}.\end{eqnarray} \tag{ 6 }$$

As we computed before the probability of a right path p_rp in equation (5), the probability of a wrong path is then

$$\begin{eqnarray}{p}_{\mathrm{wp}} & = & {p}_{\mathrm{path}}-{p}_{\mathrm{rp}}\\ & = & {(1-\varepsilon )}^{n(n-1)/2}-{(1-\varepsilon )}^{n(n+1)/2}.\end{eqnarray} \tag{ 7 }$$

(3) No-path—this error refers to the scenario where the bus never reaches any location of the qRAM. Such an error arises when a bit flip error occurs in levels 0 to $n-3.$ The smallest such tree where this error can occur is therefore a three-level tree (corresponding to a qRAM with 2³ memory cells), as shown in figure 5. The difference between a wrong path and a no-path is that, in the latter, the bus photon does not reach the memory address, hence does not read any information, whereas in the former scenario the bus reaches the wrong address in the qRAM and after the un-computing stage, the bus contains the information of some particular address in the qRAM.

Zoom In Zoom Out Reset image size

We present an example of a no-path error in figure 5, for an input address 010. At the first time instant, the first address photon (i.e. $| 0\rangle$) activates the switch (qutrit) in the first layer of the tree. At the second time instant, the address photon $| 1\rangle$ interacts with the switch in the first layer, now in state $| 0\rangle ,$ to decide the direction in which it has to be routed. Assuming no error during the second time step, the second address photon is correctly routed to the left path. Assume now that at the third time instant, a flip error occurs on the root qutrit, which flips its state from $| 0\rangle$ to $| 1\rangle .$ The third address photon would then be incorrectly routed to the path on the right. As it can be seen from figure 5, at the third time instant there are two activated switches in the second level. The readout bus photon can no longer reach any of the memory locations, and will be lost in the second level of routing tree.

The probability of a no-path event is simply

$$\begin{eqnarray}&&{p}_{\mathrm{np}}=1-{p}_{\mathrm{wp}}-{p}_{\mathrm{rp}}=1-{(1-\varepsilon )}^{n(n-1)/2}.\end{eqnarray} \tag{ 8 }$$

If the qRAM is used to implement a quantum oracle O, then O will be faulty, with an error model described by

$$\begin{eqnarray}&&\rho \overset{O}{\to }{p}_{\mathrm{rp}}\hat{O}\rho {\hat{O}}^{\dagger }+{p}_{\mathrm{wp}}{{\mathcal{E}}}_{\mathrm{wp}}(\rho )+{p}_{\mathrm{np}}{{\mathcal{E}}}_{\mathrm{np}}(\rho ),\end{eqnarray} \tag{ 9 }$$

with $\hat{O}$ denoting a perfect oracle. Here ${{\mathcal{E}}}_{\mathrm{wp}}(\cdot )$ and ${{\mathcal{E}}}_{\mathrm{np}}(\cdot )$ are error channels that corresponds to the wrong path and no-path errors, respectively.

Our error model equation (9) is less optimistic than the one of Regev and Schiff [21] of the form $\rho \overset{O}{\to }(1-p)\hat{O}\rho {\hat{O}}^{\dagger }+p\rho .$ The main difference is that the latter does not mix the amplitudes of the initial starting superposition state in Grover's search algorithm, whereas our model decoheres the system much faster due to the non-trivial errors ${{\mathcal{E}}}_{\mathrm{wp}}$ and ${{\mathcal{E}}}_{\mathrm{np}}.$ Although we do not have a proof that the quantum query complexity of our model cannot be less than the one considered in [21] (i.e. linear in N), we conjecture (based on a formal proof for a similar decoherence model, see appendix A) that this is indeed the case.

3.2. Asymptotic behavior

In figures 6–8 we analyze the probabilities of the three types of errors discussed in the previous subsection. The parameters of interest are the error probability per gate, denoted by , the overall fidelity of the addressing circuit (i.e. the probability of a right-path), denoted by p_rp, and the number of levels in the qRAM addressing binary tree denoted by n (corresponding to ${2}^{n}$ memory locations).

Zoom In Zoom Out Reset image size

For a fixed , we see that the no-path factor dominates in the error model, asymptotically with n, as depicted in figure 6.

For a fixed n, again the no-path error dominates when the error per gate becomes large, see figure 7.

Zoom In Zoom Out Reset image size

Finally, for a fixed desired overall fidelity p_rp, the maximum allowed error probability per gate to achieve the overall fidelity p_rp decays exponentially as a function of n, as plotted in figure 8. From figure 8 it can be seen that, the error rate per gate of ${\mathcal{O}}(1/{n}^{2})$ (blue line in figure 8) as considered in Giovannetti et al [4] is more optimistic than our error rate $\varepsilon (n)$ (red line in figure 8).

Zoom In Zoom Out Reset image size

For larger output fidelity p_rp, $\varepsilon (n)$ will always be bounded above by $1/{n}^{2},$ with the gap between the two increasing as p_rp approaches towards 1. Asymptotically in n, the two graphs converge towards zero.

Simply, the difference between our error $\varepsilon (n)$ and the one in [4] can best be understood by investigating the series expansion

$$\begin{eqnarray}&&{p}_{\mathrm{rp}}={(1-\varepsilon )}^{{n}^{2}}=1+2\mathrm{log}(1-\varepsilon )\displaystyle \frac{1}{n(n+1)}+{\mathcal{O}}\;(\displaystyle \frac{1}{{n}^{4}}).\end{eqnarray} \tag{ 10 }$$

In [4] the authors considered only the first order $1/{n}^{2}$ as a desirable error rate per gate. However, when the output fidelity p_rp approaches 1, this approximation is no longer accurate, and higher order terms are important. As mentioned at the end of section 2, inverse polynomial error rates are not good enough in implementing Grover's search with a qRAM-based oracle. In fact, overall error rates of at most ${\mathcal{O}}({2}^{-n/2})$ are essential.

The dominant no-path error term poses a fundamental implementation problem, due to lack of oracle information, similar (see appendix A) to the noise model investigated by Regev and Schiff [21]. If in the future, qRAM designs could be constructed without the presence of such a no-path term (i.e. with only wrong-path noise), one can attempt error correction to efficiently reduce the error rate. We demonstrate in appendix B a possible error correction scheme for a simplified wrong-path term governed by bit-flip channels, then show however that the scheme is neither applicable to our error model nor to the Regev and Schiff error model [21].

To facilitate the discussion of error correction, in this section we reformulate the physical model of bucket brigade qRAM in [4] as a quantum circuit. In figure 9 we present a possible circuit description for an $N={2}^{3}$ qubit bucket brigade qRAM, in which the memory contains only states in the computational basis $\{| 0\rangle ,| 1\rangle \}.$ Our circuit is immediately extendable to $N={2}^{n}$ and closely simulates the physical model¹³ proposed in [4].

Zoom In Zoom Out Reset image size

The circuit description of the bucket brigade addressing scheme accounts for the temporal aspects of the bucket brigade scheme. Namely, since the address qubits are introduced into the binary tree architecture sequentially, the circuit description should respect this ordering. The input to the circuit are the address qubits $| {a}_{0}{a}_{1}...{a}_{n}\rangle .$ The circuit resembles a binary tree composed of ${2}^{n}-1$ routing nodes, ${2}^{n}$ memory cells and ${2}^{n}$ readout nodes that perform the inverse operations of the routing circuit, used to decouple the qRAM from the address qubits. Additionally, a bus qubit is introduced that interacts with the memory nodes to extract the information stored in the appropriate memory location. It is worth noting that this bus qubit as described may not be physically realistic since it may interact with all the bits in the qRAM. We leave it as such, for simplicity. In practice, if such a non-local qubit is not feasible, one may either work with a phase oracle (as described in ch 8 of [23]), or one may use a binary-tree circuit to bring the result of the qRAM look-up to a specific qubit that will be accessed by the quantum algorithm that performs the look-up.

The address qubit $| {a}_{0}\rangle$ is used to activate the appropriate branch at the first level of the routing. The address qubit is coupled via a CNOT to an ancillary state prepared in the state $| 0\rangle .$ This qubit then serves as one of the input qubits along with an additional qubit prepared in the $| 1\rangle$ state for the routing node (a CNOT gate with the first qubit as control). Depending on the state of the address qubit, the resulting two-qubit output of the routing node will have a single excited qubit in the $| 1\rangle$ state, which we shall call the activated qubit. The activated branch of the tree governs the routing of the subsequent interactions with the address qubits, playing the role of the routing atom in the case of the bucket brigade outlined in [4].

The two qubits at the exit of the level-0 routing node serve as inputs to the second register of the two level-1 routing nodes. These qubits control which of the routing nodes are activated at the next level of the qRAM binary tree architecture. Namely, the qubit that is excited in the $| 1\rangle$ state allows for the coupling between the address qubit and an introduced $| 0\rangle$ state ancilla via a Toffoli gate. Therefore the input to the active routing node is either $| 01\rangle$ or $| 11\rangle$ depending on the state of the address qubit $| {a}_{1}\rangle .$ Effectively, the routing operation given by a CNOT gate activates a branch of the tree. For the node that is non-active, the state at the output of the previous level is $| 0\rangle ,$ meaning the Toffoli is not activated and the resulting input and output state to the routing node remains $| 00\rangle .$

Therefore, after two routing node levels, the output of the routing qubits is composed of 2² qubits, with only a single branch being excited depending on the state of the first two address qubits $| {a}_{0}{a}_{1}\rangle .$ Therefore, this corresponds to an isometry:

$$\begin{eqnarray}{| 00\rangle }_{{a}_{0}{a}_{1}} & \to & | 0001\rangle \\ {| 01\rangle }_{{a}_{0}{a}_{1}} & \to & | 0010\rangle \\ {| 10\rangle }_{{a}_{0}{a}_{1}} & \to & | 0100\rangle \\ {| 11\rangle }_{{a}_{0}{a}_{1}} & \to & | 1000\rangle ,\end{eqnarray} \tag{ 11 }$$

where the excited output qubits in the $| 1\rangle$ state represent an active physical path for the subsequent qRAM operations. This procedure is repeated for n levels, where at the kth level there are ${2}^{k}$ Toffoli gates and routing nodes. The ${2}^{k}$ Toffoli gates are required to route of the address qubit $| {a}_{k}\rangle$ through the previous k levels and the routing node establish the output states in order to route the subsequent address qubits. Since such a circuit performs the appropriate unitary mapping of the address qubits for all computational basis state inputs, by linearity it will extend to all superpositions of input address qubits. An example of the routing procedure for a three-qubit input address state $| 010\rangle$ is presented in figure 9, where the blue highlighted nodes correspond to the activated nodes.

After the completion of the n routing node levels, memory readout is performed. The reading is performed by introducing a bus qubit prepared in the $| 0\rangle$ state which is the target of ${2}^{n}$ Toffoli gates. Each of the ${2}^{n}$ qubits at the output of the qRAM routing nodes pair with one of the memory cells to serve as control qubits for the Toffoli gates. Since only a single output qubit from the routing scheme is activated, only a single Toffoli gate couples with a memory location to the bus qubit. The bus qubit is represented by the bottom qubit in figure 9 while the 2³ memory qubits are represented between the qRAM routing architecture and the bus qubit.

Having completed the coupling of the address qubit, the state of the qRAM routing qubits must be decoupled from the address and bus qubits. Each of the gates from the routing circuit are performed in reverse order, which corresponds to performing the inverse unitary coupling transformation between the address qubits and the routing qubits. The resulting state couples the address qubits with the corresponding memory qubit and has decouples the routing qubits to their input ancillary states.

The results from section 3 motivate the need for quantum error correction to be implemented at each node in order to protect against errors that may cause detrimental faults in path information.

5.1. Imposing a QECC

5.2. Number of activations in a CSS code

In the implementation of Giovanetti et al [4], one of the primary advantages is the number of gate activations that are needed per level of the bucket brigade scheme. More simply, a CNOT (Toffoli) gate in their scheme is 'activated' only when the control qubit(s) is (are) in the state $| 1\rangle .$ Since only one register is in such a state at a given level, the total number of activations can thus be kept low. In a physical implementation, this is relevant as an activated path may represent the presence of a physical excitation without which no physical process occurs, therefore one can think of these non-activated gates as in fact being the identity operation. However, such an advantage vanishes when imposing a CSS code in order to protect from errors due to the symmetry in the number of $| 0\rangle$ and $| 1\rangle$ states the logical states encoding the path information.

In the CSS code construction, two classical codes were taken to form a QECC. Therefore, given some codeword of the classical code $c\in {{\mathcal{C}}}_{Z},$ the equivalent quantum state written out in computation basis $| c\rangle$ must be stabilized by the Z generators of the code, by definition of being a codeword of the classical code ${{\mathcal{C}}}_{Z}.$ However, in order to be a logical state of the CSS code, it must also be stabilized by the elements of the group generated by the X stabilizers. Therefore, the codestate will be the superposition of the application of all X stabilizers upon $| c\rangle$

$$\begin{eqnarray}&&| c+{{\mathcal{C}}}_{Z}^{\perp }\rangle =\displaystyle \sum _{x\in {{\mathcal{C}}}_{Z}^{\perp }}| c+x\rangle =\displaystyle \frac{1}{{2}^{n-{k}_{X}}}\displaystyle \prod _{i}({I}^{\otimes n}+{S}_{X,i})| c\rangle ,\end{eqnarray} \tag{ 12 }$$

where $\{{S}_{X,i}\}$ are the generators of the X stabilizer group, equivalently given by the rows of the parity check matrix H_X.

Consider the form of equation (12), given the state $| c\rangle$ written in the computational basis, the action of the operator $({I}^{\otimes n}+{S}_{X,1})$ will be the equally weighted superposition of the state $| c\rangle$ and ${S}_{X,1}| c\rangle ,$ which will differ at the location where ${S}_{X,1}$ has a Pauli X in its description. Therefore, at these locations half of the states in the superposition will have a physical $| 0\rangle$ state and half will have a physical $| 1\rangle$ state. Then acting upon the state with the operator $({I}^{\otimes n}+{S}_{X,2})$ will have the same effect on all the states in the superposition, with now an even number of physical $| 0\rangle$ and $| 1\rangle$ states occurring at location with Pauli X in ${S}_{X,2}.$ Repeating this for all X generators, any location with a X operator in one of the stabilizers will necessarily have half of the states in the superposition in each of the physical basis states. In order for the code to protect against any arbitrary single qubit error, each physical qubit must be protected by at least one X stabilizer operator with support the given location, otherwise it would be vulnerable to a single Z error at this location. As such, all relevant CSS codesstate will have an equal number of each of the physical basis states when writing out the expansion of the state in the computational basis.

In a physical implementation, such as that of Giovanetti et al [4], a qubit in the state $| 1\rangle$ represents an activated physical process, and as such the advantage of the bucket brigade scheme is that the number of such processes are kept low. However, due to the symmetry in the number of activations that must exist in both the logical ground and excited states, this advantage no longer exists when considering CSS codes. More generally, non-symmetric codes, that is codes where the logical $| 0\rangle$ state and logical $| 1\rangle$ have a differing number of physical states in the excited state $| 1\rangle ,$ are not desirable for the purposes of error correction as they will be more susceptible to Z errors. The three-qubit repetition code is an extreme example of such a property.

In principle, for the physical error model discussed in section 3, one can envision using the detection of a photon lost in the routing structure as a means to correct for no-path errors (see figure 5). However, detecting the exact node at which a photon was lost reveals path information about the state being read by the qRAM (since the previous node in the routing structure would have necessarily been activated by the address qubits) which leads to a loss of coherence in the system. Therefore, any photon detection has to identify the level at which the photon was lost, while not revealing exactly where. It is hard to envisage a practical means for experimentally realizing a photon detection with this property (for example, by somehow symmetrizing the loss of the photon across the exponentially many nodes at a given level). Furthermore, even if this is achieved, one still faces the problem that the lost photon contained path information. Thus, destroying the photon with this path information is equivalent to a dephasing error leading to a further loss of coherence.

In conclusion, if one encodes each node of the bucket brigade qRAM in an error correcting code, then all nodes of the circuit are activated at a physical level, and essentially the qRAM architecture becomes equivalent to a fanout architecture. Even it the latter case, designing a good QECC is highly non-trivial. An important issue is that the syndrome measurement should not reveal any information whatsoever about the physical location of the nodes affected by errors. Otherwise, path information is being revealed, which decoheres the system.

We analyzed the robustness of the bucket brigade qRAM scheme introduced in [3, 4] under an optimistic error model.

The primary advantage of the bucket brigade scheme is the need for a polynomial in n (rather than exponential) number of gate activations per memory reading. When used for quantum algorithms [9–14] that require only a polynomial number of queries, the error rate of the qRAM can scale polynomially in n, and error correction may not be required. By contrast, when the qRAM is used as an oracle for quantum searching, its error rate per gate has to scale as $o({2}^{-n/2})$ [4], motivating the need for quantum error correction.

We argued that using traditional error correcting techniques offsets the main advantage of the bucket brigade scheme when used with algorithms that make super-polynomially many oracle queries. Since each component of the routing architecture has to be actively error corrected in order to protect against detrimental faults, the overall scheme requires an exponential number of physical gate activations, even if the number of logical gate activations remains polynomial.

An interesting open question is the existence of a realistic architecture-specific error correction technique that could recover the polynomial number of physical gate activations of the routing scheme while still guaranteeing fault-tolerance. For example, if one tries to use an error correction mechanism whereby one only uses multi-qubit code states along the active path, then one has the problem of extracting syndromes and applying corrections in a way that does not identify which path has the non-trivial syndromes (since such information would lead to decoherence). If in this case, for example, one attempts to extract the syndrome without leaving a trace of which node in a given level it came from, then the problem seems at least as challenging as implementing a reliable qRAM.

Moreover, it would be interesting to investigate whether the requirement for a super-polynomial suppression of the error rate is a characteristic of quantum searching algorithms or a more general feature of query complexity with faulty oracles.

We thank Daniel Gottesman, Stacey Jeffery, Seth Lloyd, Lorenzo Maccone and Matteo Mariantoni for numerous insightful discussions and suggestions. We thank Seth Lloyd for pointing out to us nice examples of important algorithms that only use polynomially many queries. The authors were supported in part by NSERC, CIFAR, FQRNT, OGS, CryptoWorks21 and Industry Canada. IQC and PI are supported in part by the Government of Canada and the Province of Ontario. SA is grateful to Ronald de Wolf's ERC Consolidator Grant QPROGRESS and Michele Mosca for support from NSERC.

Let us consider the error model considered in [21]

$$\begin{eqnarray}&&{{\mathcal{R}}}_{p}(\rho ):= (1-p)\hat{O}\rho {\hat{O}}^{\dagger }+p\rho ,\end{eqnarray} \tag{ A.1 }$$

with $\hat{O}$ denoting the perfect oracle for quantum searching and let us define

$$\begin{eqnarray}&&{{\mathcal{D}}}_{q}(\rho ):= (1-q)\rho +q\vec{X}\rho {\vec{X}}^{\dagger }\end{eqnarray} \tag{ A.2 }$$

as the multi-qubit bit-flip channel where $\vec{X}$ is a shorthand notation for a tensor product of ${\sigma }_{X}$ bit-flip operators acting on some fixed subset of the qubits. The proof technique presented below for ${{\mathcal{D}}}_{q}$ also applies to the case of multi-qubit dephasing channels).

The error model proposed in this paper (see equation (9)) is

$$\begin{eqnarray}&&O(\rho ):= {p}_{\mathrm{rp}}\hat{O}\rho {\hat{O}}^{\dagger }+{p}_{\mathrm{wp}}{{\mathcal{E}}}_{\mathrm{wp}}(\rho )+{p}_{\mathrm{np}}{{\mathcal{E}}}_{\mathrm{np}}(\rho ).\end{eqnarray} \tag{ A.3 }$$

We show that the composition ${{\mathcal{R}}}_{p}\;\circ \;{{\mathcal{D}}}_{q}$ resembles (although not exactly the same) our error model equation (9), for suitable chosen p and q. It follows immediately that the ${\rm{\Omega }}(N)$ lower bound for the searching algorithm considered in [21] is also a lower bound for the composition ${{\mathcal{R}}}_{p}\;\circ \;{{\mathcal{D}}}_{q},$ since channel composition cannot decrease the query complexity (one can simply incorporate ${{\mathcal{D}}}_{q}$ into an appropriate unitary for the ${{\mathcal{R}}}_{p}$ algorithm). A simple calculation yields:

$$\begin{eqnarray}{{\mathcal{R}}}_{p}\;\circ \;{{\mathcal{D}}}_{q}(\rho ) & = & (1-p)\hat{O}{{\mathcal{D}}}_{q}(\rho ){\hat{O}}^{\dagger }+p{{\mathcal{D}}}_{q}(\rho )\\ & = & (1-p)(1-q)\hat{O}\rho {\hat{O}}^{\dagger }+(1-p)q\hat{O}(\vec{X}\rho {\vec{X}}^{\dagger }){\hat{O}}^{\dagger }+p(1-q)\rho +{pq}\vec{X}\rho {\vec{X}}^{\dagger }\\ & = & (1-p)(1-q)\hat{O}\rho {\hat{O}}^{\dagger }+(1-p)q\hat{O}(\vec{X}\rho {\vec{X}}^{\dagger }){\hat{O}}^{\dagger }+p{{\mathcal{D}}}_{q}(\rho ).\end{eqnarray} \tag{ A.4 }$$

We now identify the coefficients in equations (A.3) and (A.4)

$$\begin{eqnarray}\left\{\begin{array}{rcl}{p}_{\mathrm{rp}} & = & (1-p)(1-q)\\ {p}_{\mathrm{wp}} & = & (1-p)q\\ {p}_{\mathrm{np}} & = & p,\end{array}\right.\end{eqnarray} \tag{ A.5 }$$

and note that for any given probabilities ${p}_{\mathrm{rp}},{p}_{\mathrm{wp}},{p}_{\mathrm{np}}$ satisfying ${p}_{\mathrm{rp}}+{p}_{\mathrm{wp}}+{p}_{\mathrm{np}}=1,$ equations (A.5) have the solution

$$\begin{eqnarray}\left\{\begin{array}{rcl}p & = & {p}_{\mathrm{np}}\\ q & = & \displaystyle \frac{{p}_{\mathrm{wp}}}{{p}_{\mathrm{wp}}+{p}_{\mathrm{rp}}}.\end{array}\right.\end{eqnarray} \tag{ A.6 }$$

We can therefore write

$$\begin{eqnarray}&&{{\mathcal{R}}}_{p}\;\circ \;{{\mathcal{D}}}_{q}(\rho )={p}_{\mathrm{rp}}\hat{O}\rho {\hat{O}}^{\dagger }+{p}_{\mathrm{wp}}\hat{O}(\vec{X}\rho {\vec{X}}^{\dagger }){\hat{O}}^{\dagger }+{p}_{\mathrm{np}}{{\mathcal{D}}}_{q}(\rho ).\end{eqnarray} \tag{ A.7 }$$

Comparing equations (A.3) and (A.7), we observe that the term $\hat{O}(\vec{X}\rho {\vec{X}}^{\dagger }){\hat{O}}^{\dagger }$ is very similar to our wrong path term ${{\mathcal{E}}}_{\mathrm{wp}}(\rho )$ (the error that corresponds to reading out an incorrect memory location). The last term term ${{\mathcal{D}}}_{q}(\rho )$ in equation (A.7) is not of the form of our no-path error term ${{\mathcal{E}}}_{\mathrm{np}}(\rho ),$ as the latter consists of depolarizing channels of different strengths depending on the position of the address qubit (i.e., the qubits are affected in decreasing order of significance, that is, the first qubit is affected the most, while the last one the least). However, ${{\mathcal{D}}}_{q}(\rho )$ is a decohering term, which seems to be a 'weaker' form of noise than ${{\mathcal{E}}}_{\mathrm{np}}(\rho ).$ We showed above that even with this weaker decoherence term the quadratic speedup of any searching algorithm is lost. Therefore we have strong reasons to believe that adding a stronger decoherence term will not lower the quantum query complexity for the quantum searching problem. A rigorous proof of this conjecture remains an open problem.

B.1. Correcting simple bit-flip errors

We show below that for a qRAM governed by a toy error model of the form

$$\begin{eqnarray}&&O(\rho )=(1-p)\hat{O}\rho {\hat{O}}^{\dagger }+p\hat{O}(\vec{X}\rho {\vec{X}}^{\dagger }){\hat{O}}^{\dagger },\end{eqnarray} \tag{ B.1 }$$

the query error rate can be made arbitrarily small by using quantum error correction. Here $\hat{O}$ denotes the perfect oracle and $\vec{X}$ represents a multi-qubit bit-flip channel (a tensor product of individual bit-flip operators acting on an arbitrary subset of qubits). While such error models are not realistic for the architecture presented in this work, it may be that future designs allow for simpler error propagation. Such schemes could benefit from quantum error correction to sufficiently reduce their error rate to enable Grover search.

As Grover's algorithm requires ${\mathcal{O}}(\sqrt{N})$ steps, one desires a target logical error rate of $\delta ={\mathcal{O}}(1/\sqrt{N}).$ Since the faulty oracle has an error model that consists of a bit flip channel followed by the perfect oracle call, one can use a QECC and apply the oracle in parallel along the qubits composing the code. The parallelism of the oracle calls mimics majority counting and allows for error correction to be performed between logical oracle call steps. For simplicity, we provide an example that corrects against bit flip errors only using the repetition code, however such an analysis could be extended to correct for phase flips using code families such as the color codes [32], higher dimensional Shor codes [33], or triorthogonal codes [34].

For example, consider an oracle of the form $| a\rangle | b\rangle \to | a\rangle | b\oplus f(a)\rangle ,$ where $a,b\in \{0,1\}.$ A logical oracle call that uses an n-qubit repetition code behaves as follows for states in the computational basis:

$$\begin{eqnarray}&&| a\rangle | b\rangle \overset{V}{\to }{| a\rangle }^{\otimes n}{| b\rangle }^{\otimes n}\overset{{\hat{O}}^{\otimes n}}{\longrightarrow }{| a\rangle }^{\otimes n}{| b\oplus f(a)\rangle }^{\otimes n},\end{eqnarray} \tag{ B.2 }$$

where V denotes the isometric encoding. Therefore, given a repetition code of length d, the code corrects for all errors up to $d/2-1$ physical bit flips by majority counting, using non-destructive Z-type stabilizer measurements. Therefore, the logical error rate becomes ${p}_{L}={p}^{d/2}.$ Choosing d large enough allows the logical error rate to satisfy ${p}_{L}={p}^{d/2}\lt \delta ,$ where δ is the desired target fidelity. Therefore

$$\begin{eqnarray}&&d\gt \displaystyle \frac{2\mathrm{log}\delta }{\mathrm{log}p}=\displaystyle \frac{2\mathrm{log}\left(1/\sqrt{N}\right)}{\mathrm{log}p}=\displaystyle \frac{n}{\mathrm{log}\left(1/p\right)}.\end{eqnarray} \tag{ B.3 }$$

Each of the n address qubits that serve as input to the oracle call must be encoded into a repetition code of length d. Hence, the total number of oracle calls for the complete Grover search algorithm is ${\mathcal{O}}({nd}\sqrt{N})={\mathcal{O}}({n}^{2}\sqrt{N})={\mathcal{O}}(\sqrt{N}{(\mathrm{log}N)}^{2}).$ As such, there is a logarithmic penalty for error correction, yet the scaling is not linear as in the error model of Regev and Schiff [21].

B.2. The failure of repetition codes for the Regev and Schiff error model

The above error correction scheme is not applicable to the error model presented in [21], described by ${{\mathcal{R}}}_{p}(\rho )=(1-p)\hat{O}\rho {\hat{O}}^{\dagger }+p\rho ,$ since the failure of an oracle call can lead to an uncorrectable error, as demonstrated below. Consider the following example of the three-qubit repetition code, where rather than all three oracles calls succeeding, the oracle call on the first set of qubits fails. The computational states evolve as:

$$\begin{eqnarray}&&| 000\rangle | 000\rangle \overset{{\hat{O}}_{2}{\hat{O}}_{3}}{\longrightarrow }| 000\rangle | 0\;f(0)f(0)\rangle \end{eqnarray} \tag{ B.4 }$$

$$\begin{eqnarray}&&| 111\rangle | 000\rangle \overset{{\hat{O}}_{2}{\hat{O}}_{3}}{\longrightarrow }| 111\rangle | 0\;f(1)f(1)\rangle .\end{eqnarray} \tag{ B.5 }$$

Consider the action of such a faulty oracle on the encoded state $(| 000\rangle +| 111\rangle )/\sqrt{2},$ for $f(0)=0$ and $f(1)=1.$ The resulting mapping is

$$\begin{eqnarray}&&\displaystyle \frac{1}{\sqrt{2}}(| 000\rangle +| 111\rangle )\otimes | 000\rangle \\ &&\overset{{\hat{O}}_{2}{\hat{O}}_{3}}{\longrightarrow }\displaystyle \frac{1}{\sqrt{2}}(| 000\rangle | 000\rangle +| 111\rangle | 011\rangle ).\end{eqnarray} \tag{ B.6 }$$

The syndrome check operators for the repetition code are the parity check operators $\{{Z}_{1}{Z}_{2},{Z}_{2}{Z}_{3}\}.$ They are used to determine if an oracle call has failed by measuring the ancilla qubits. However, the measurement collapses the state to either $| 000\rangle | 000\rangle$ or $| 111\rangle | 011\rangle .$ Upon applying the appropriate correction based on the measured syndromes, the resulting state becomes either $| 000\rangle | 000\rangle$ or $| 111\rangle | 111\rangle .$ Therefore, the logical oracle call has failed, since the correct result must yield the superposition $(| 000\rangle | 000\rangle +| 111\rangle | 111\rangle )/\sqrt{2}.$

As expected, the error correction properties of the repetition code are not in violation of the results of [21], which state that a linear number of noisy black-box oracle calls are required, even with the addition of error correction.

B.3. The failure of repetition codes for our error model

Consider the oracle error model:

$$\begin{eqnarray}&&O(\rho ):= {p}_{\mathrm{rp}}\hat{O}\rho {\hat{O}}^{\dagger }+{p}_{\mathrm{wp}}{{\mathcal{E}}}_{\mathrm{wp}}(\rho )+{p}_{\mathrm{np}}{{\mathcal{E}}}_{\mathrm{np}}(\rho ),\end{eqnarray} \tag{ B.7 }$$

where $\hat{O}$ is the perfect oracle call while ${{\mathcal{E}}}_{\mathrm{wp}}(\rho )$ and ${{\mathcal{E}}}_{\mathrm{np}}(\rho )$ are the wrong path and no-path terms, respectively. We model the wrong path term as a convex combinations of bit-flip channels followed by perfect oracle calls. An example of one of those terms is the second term in equation (B.1). We model the no-path term as taking any input state and mapping it to a fixed state $| g\rangle ,$ which represents the loss of a qubit to be replaced by any fixed ancillary state. It should be noted that in the no-path case, the readout ancilla state does not change. Consider the action of the noisy channel on the five-qubit repetition code. Each instance of the channel has a certain probability of failure given by the associated weights. Focusing on one particular instance where the first address photon is lost and the second is affected by a bit flip, the resulting mapping on the computational basis states is given by:

$$\begin{eqnarray}&&| 00000\rangle | 00000\rangle \;\longrightarrow \;| g1000\rangle | 0f(1)f(0)f(0)f(0)\rangle \end{eqnarray} \tag{ B.8 }$$

$$\begin{eqnarray}&&| 11111\rangle | 00000\rangle \;\longrightarrow \;| g0111\rangle | 0f(0)f(1)f(1)f(1)\rangle .\end{eqnarray} \tag{ B.9 }$$

Again choosing $f(0)=0$ and $f(1)=1,$ a superposition of input states in the computational basis evolves as

$$\begin{eqnarray}&&\displaystyle \frac{1}{2}P\left[\left(| 00000\rangle +| 11111\rangle \right)\otimes | 00000\rangle \right]\\ &&\quad \longrightarrow \displaystyle \frac{1}{2}\left(P\left[| g1000\rangle \otimes | 01000\rangle \right]+P\left[| g0111\rangle \otimes | 00111\rangle \right]\right),\end{eqnarray} \tag{ B.10 }$$

where $P[\bullet ]$ denotes the projector onto its argument. The measurement of the stabilizers of the five-qubit code on the ancillary states results in the collapse of the state into one of two terms depending on the syndrome measured. Note that the no-path term is the term that destroys coherence, similarly to the error term in the Regev and Schiff model [21].