Fault-Tolerant Quantum Computing in the Pauli or Clifford Frame with Slow Error Diagnostics

TL;DR

This paper introduces a fault-tolerant quantum computing scheme that operates effectively despite slow error diagnostics, reducing overhead and enhancing error thresholds by utilizing a Clifford frame approach.

Contribution

It presents a novel fault-tolerance protocol that does not require active correction and adapts to Clifford-based error correction strategies, improving efficiency and robustness.

Findings

Reduces error correction overhead with slow diagnostics

Increases error thresholds using Clifford frame protocol

Applicable to various quantum computation scenarios

Abstract

We consider the problem of fault-tolerant quantum computation in the presence of slow error diagnostics, either caused by measurement latencies or slow decoding algorithms. Our scheme offers a few improvements over previously existing solutions, for instance it does not require active error correction and results in a reduced error-correction overhead when error diagnostics is much slower than the gate time. In addition, we adapt our protocol to cases where the underlying error correction strategy chooses the optimal correction amongst all Clifford gates instead of the usual Pauli gates. The resulting Clifford frame protocol is of independent interest as it can increase error thresholds and could find applications in other areas of quantum computation.

Equations

$$\displaystyle H=\frac{1}{\sqrt{2}}\left(\begin{array}[]{cc}1&1\\ 1&-1\\ \end{array}\right),\ \ {\rm and}\ \ S=\frac{1}{\sqrt{2}}\left(\begin{array}[]{cc}1&0\\ 0&i\\ \end{array}\right),$$

$$C\text{mbox}-U_{12}=\frac{1}{2}(I+Z)\otimes I+\frac{1}{2}(I-Z)\otimes U.$$

$$(S\otimes I)C\text{mbox}-X_{12}$$

$$(I\otimes S)C\text{mbox}-X_{12}$$

$$(I\otimes H)C\text{mbox}-X_{12}$$

$$(H\otimes I)C\text{mbox}-X_{12}$$

$$C\text{mbox}-X_{12}(C_1\otimes C_2)=(C_1^{\prime }\otimes C_2^{\prime })C\text{mbox}-X_{12},$$

$$C_{good}=(C_1\otimes C_2)C\text{mbox}-X_{12}.$$

$$C_{bad}={\mathcal{P}}_2^{(2)}\setminus C_{good},$$

$$C_{-}=⟨S,X⟩,\mathrm{and}{C}_{+}={\mathcal{P}}_1^{(2)}\setminus C_{-}.$$

$${\mathcal{T}}^{(k)}=\prod _{j=1}^k(T{C}_j)\mathrm{where}{C}_j\in C_{+}.$$

$$P_{2j+1}=\frac{1}{j+1}\left(\genfrac{}{}{0ex}{}{2j}{j}\right)p^j(1-p{)}^{j+1}.$$

$$\sum _{k\ge 0}{P}_{2k+1}=\min \left\{\frac{1-p}{p},1\right\}.$$

$$F(p,n)$$

$$=1-f(p,n),$$

$$f(p,n)$$

$$\times {}_2{F}_1(1,\frac{3}{2}+n;3+n;4p(1-p)),$$

$$\displaystyle\binom{2(n+1)}{n+1}\geq\Bigg{(}\frac{2(n+1)}{(n+1)}\Bigg{)}^{n+1}=2^{n+1},$$

$${}_2{F}_1(1,\frac{3}{2}+n;3+n;4p(1-p))\ge 2p+1.$$

$$F(p,n)\le 1-\frac{(1-p)(2p+1)}{n+2}[2p(1-p){]}^{n+1}.$$

$$\frac{[2p(1-p){]}^{n+1}}{n+2}\le \frac{ϵ}{(1-p)(2p+1)}$$

$$[p(1-p){]}^{n+1}\le \frac{ϵ}{(1-p)(2p+1)}$$

$$\mathcal{E}(\bar{\rho })\mapsto T_s{\Pi }_s\mathcal{E}(\bar{\rho }){\Pi }_s{T}_s.$$

$$\varphi =\sum _a\mathrm{Tr}\left(T_s{\Pi }_s\mathcal{E}(\bar{\rho }){\Pi }_s{T}_s\cdot {\bar{P}}_a\right)P_a$$

$$\mathcal{J}(\mathcal{E})=\frac{1}{4}\sum _{i,j}\mathcal{E}(P_i)\otimes P_j^T$$

$${\Lambda }_{ij}=\mathrm{Tr}\left(\mathcal{J}(\mathcal{E})\cdot (P_j\otimes P_i^T)\right).$$

$$\Lambda (\mathcal{E}{)}_{ij}$$

$$=\mathrm{Tr}\left(P_{\sigma (i)}\cdot P_j\right)={\delta }_{\sigma (i),j}$$

$${\Lambda }_{ij}^{(1)}$$

$$=\mathrm{Tr}\left(\mathcal{E}({\Pi }_0\cdot {\bar{P}}_i)\cdot {\Pi }_s\cdot {\bar{P}}_j\right)$$

$$=\sum _{\begin{array}{c}l\\ P_l\in {\bar{P}}_i\cdot \mathcal{S}\end{array}}\sum _{\begin{array}{c}k\\ P_k\in {\bar{P}}_j\cdot \mathcal{S}\end{array}}{c}_k{\Lambda }_{lk}$$

$$=\sum _{\begin{array}{c}l\\ P_l\in {\bar{P}}_i\cdot \mathcal{S}\end{array}}\sum _{\begin{array}{c}k\\ P_k\in {\bar{P}}_j\cdot \mathcal{S}\end{array}}{c}_k{\delta }_{l,\sigma (k)}$$

Full text

\pacs

03.67.Pp

1 Introduction and Motivation

In fault-tolerant quantum computation, syndrome measurements are used to detect and diagnose errors. Once diagnosed, an error can be corrected before it propagates through the rest of the computation. In this article, we are concerned with the impact of slow error diagnostics on fault-tolerance schemes. There are two origins for this concern. First, in certain solid-state and ion-trap qubit architectures, measurement times can be between 10 to 1000 times slower than gates times [1, 2, 3, 4, 5, 6, 7]. Thus, on the natural operating time-scale of the quantum computer, there is a long delay between an error event and its detection. Second, processing the measurement data to diagnose an error—i.e., decoding—can be computationally demanding. Thus, there can be an additional delay between the data acquisition and the error identification. At first glance, these delays might cause the error probability to build up between logical gates, thus effectively decreasing the fault-tolerance threshold. But as we will see, this is not necessarily the case.

One of the key tricks to cope with slow error diagnostics is the use of error frames [8]. While the basic idea of error correction is to diagnose and correct errors, it can often be more efficient to keep track of the correction in classical software instead of performing active error correction. In particular, this saves us from performing additional gates on the system, thus removing potential sources of errors. In most quantum error-correction schemes, the correction consists of a Pauli operator, i.e., tensor products of the identity $I$ and the three Pauli matrices $X,\ Y,$ and $Z$. Thus, at any given time, the computation is operated in a random but known Pauli frame: its state at time $t$ is $P|\psi(t)\rangle$ for some Pauli operator $P$ and where $|\psi(t)\rangle$ denotes the ideal state at time $t$. When error-diagnostics is slow, the system will unavoidably evolve in an unknown error frame for some time.

The problem of slow measurements in solid-state systems was addressed by DiVincenzo and Aliferis [9] in the context of concatenated codes. In addition to error diagnostics, concatenated schemes require measurements to prepare certain ancilla states used to fault-tolerantly extract the error syndrome and to inject magic states to complete a universal gate set. DiVincenzo and Aliferis’ scheme hinges on the fact that the logical gate rate decreases exponentially with the number of concatenation levels; thus, at a sufficiently high level, measurement and gate times become commensurate. To concretely realize this simple observation, they combine a number of known and new techniques including ancilla correction, high-level state injection, and Pauli frames.

One limitation of this solution is that it only applies to concatenated codes realizing a universal gate set through magic state injection. This leaves out for instance surface codes [10] or concatenated codes with alternate universal gate constructions [11, 12, 13, 14, 15, 16]. In particular, they inject noisy magic-states directly at high concatenation levels, thus losing the benefit of low-level correction. In addition, when decoding times are very slow, this solution could wastefully use additional layers of concatenation with the sole purpose of slowing down the logical gates. Another drawback of their scheme is that it requires active error correction to ensure that high-level corrections are always trivial.

In this article, we introduce an alternative scheme to cope with slow error diagnostics which applies broadly to all codes and universal gate constructions. Like the DiVincenzo and Aliferis scheme, the key idea will be to slow-down the logical gate rate to learn the error frame before it propagates to the rest of the computation. This is simply achieved by spacing out gates in the logical circuit and thus circumvents the unnecessary additional qubit overhead associated to extra concatenation layers. Our scheme does not require active error correction, it is entirely realized in an error frame. In addition, our scheme is compatible with a more general form of error correction which uses Clifford frames, where at any given time $t$, the state of the computer is $C|\psi(t)\rangle$ where $C$ is a tensor-product of single-qubit Clifford group elements (defined below). Note that details of the Pauli frame scheme are given in Section 2 whereas details of the Clifford frame scheme are given in Section 3.

Regarding slow measurements, it is important to distinguish two time scales. First, the time $t_{l}$ it takes for the outcome of a measurement to become accessible to the outside world. For instance, $t_{l}$ could be caused by various amplification stages of the measurement, and we refer to it as a measurement latency. Second, the measurement repetition time $t_{r}$ is the minimum time between consecutive measurements of a given qubit. In principle, $t_{r}$ can be made as small as the two-qubit gate time, provided that a large pool of fresh qubits are accessible. Indeed, it is possible to measure a qubit by performing a CNOT to an ancillary qubit initially prepared in the state $|0\rangle$ and then measuring this ancillary qubit. While the ancillary qubit may be held back by measurement latencies for a time $t_{l}$ before it can be reset and used again, other fresh qubits can be brought in to perform more measurements in the meantime. The scheme we present here and the one presented in [9] are designed to cope with measurement latencies $t_{l}$, but both require small $t_{r}$. Indeed, the accuracy threshold is a function of the error rate per gate time (including measurement gates). Thus, increasing the measurement repetition time $t_{r}$ relative to the decoherence rate will unavoidably yield a lower threshold.

While the DiVincenzo and Aliferis scheme was motivated by slow measurements, most of it applies directly to the case of slow decoding. Our scheme too is oblivious to the origin of slow error diagnostics. We emphasize that slow decoding is a very serious concern. For instance, numerical simulations used to estimate the threshold or overhead of the surface code are computationally dominated by the decoding algorithm and require intense computational resources. Depending on the code distance and error rate, a single decoding cycle can take well above 1$\mu s$ [17] on a standard processor, considerably slower than the natural GHz gate rate in the solid state.

As explained in [18], if the rate of the classical syndrome processing (decoding) is smaller than the rate at which the syndrome is generated, an exponential slow down would occur during the computation. However, just as measurements with long latencies can be handled with a supply of additional fresh measurement qubits, slow decoding can be handled with a supply of parallel classical computers so that the overall decoding rate matches the syndrome creation rate. Thus, in this article, slow error diagnostics is used to designate latencies in measurements and/or decoding.

Finally, to our knowledge, a theory of Clifford frames for fault-tolerant quantum computation has not been worked out before. By enabling them, our scheme offers a greater flexibility for error correction, thus potentially correcting previously non-correctable error models, or increasing the threshold of other noise models [19]. More generally, the possibility of fault-tolerantly computing in a Clifford frame opens up the door to new fault-tolerant protocols, e.g., using new codes or new hardware that have a different set of native fault-tolerant gates. For instance, Clifford frames were used as an accessory in measurement-based quantum computation with Majorana fermions [20]. Lastly, the possibility of computing in a Clifford frame could have applications to randomized compiling [21] which introduces random frames to de-correlate physical errors.

2 Pauli frame

For the remainder of the paper, we will often make use of the following definitions. First, we define $\mathcal{P}_{n}^{(1)}$ to be the $n$-qubit Pauli group (i.e. $n$-fold tensor products of the identity $I$ and the three Pauli matrices $X,\ Y,$ and $Z$). Then the Clifford hierarchy is defined by $\mathcal{P}_{n}^{(k)}=\{U:UPU^{\dagger}\in\mathcal{P}_{n}^{(k-1)}\quad\forall P\in\mathcal{P}_{n}^{(1)}\}$.

In physical implementations where measurement times are much longer than gate times or when error decoding is slow, if one were to perform active error correction, a large number of errors could potentially build up in memory during the readout times of the measurement. However, for circuits containing only Clifford gates, all Pauli recovery operators can be tracked in classical software without ever exiting the Pauli group. Indeed, suppose that at some given time during the computation, the state of the computer is in some Pauli frame defined by $P$—i.e., the state of the computer is $P|\psi\rangle$ where $|\psi\rangle$ is the ideal state (here $P$ can be any element of $\mathcal{P}_{n}^{(1)}$, not necessarily a logical Pauli operator). If we then apply a Clifford gate $U\in\mathcal{P}_{n}^{(2)}$ (again, not necessarily a logical gate), then the state will be $UP|\psi\rangle=P^{\prime}U|\psi\rangle$ where $P^{\prime}$ is another Pauli operator. We thus see that the effect of $U$ is to correctly transform the perfect state $|\psi\rangle$ and to change the Pauli frame $P$ in some known way. Moreover, updating the Pauli frame $P^{\prime}=UPU^{\dagger}$ can be done efficiently, with complexity $\mathcal{O}(n^{2})$ [22]. This shows that as long as we only apply Clifford gates, there is no need to actively error-correct, we can instead efficiently keep track of the Pauli frame in classical software [8].

In concatenated codes for instance, error correction is performed in between the application of gates to ensure that errors don’t accumulate in an uncontrolled fashion. A gate location in a quantum algorithm is thus replaced by an extended rectangle, where error correction is performed both before and after the application of the gate [23]. The leading error correction circuit in an extended rectangle is used to correct input errors that could have occurred prior to the application of the gate. The trailing error correction circuits correct errors that can occur during the application of the gate (see Fig. 1). Each error correction circuit will multiply the current Pauli frame by a Pauli operator (the correction).

Since Clifford gates can be efficiently simulated on a classical computer, non-Clifford gates are needed for universal quantum computation. Universal quantum computation can be achieved for instance using gates from the Clifford group combined with the $T=\mathrm{diag}(1,e^{i\pi/4})\in\mathcal{P}_{1}^{(3)}$ gate [24]. In general, Pauli operators will not remain in the Pauli-group when conjugated by non-Clifford gates and so the Pauli frame cannot simply propagate through them.

Consider the application of a logical $T$ gate in a quantum algorithm. Since measurement times are much longer than gate times, the Pauli frame right before the application of a $T$ gate can only be known at a later time. Furthermore, by definition of the Clifford hierarchy, Pauli operators are mapped to Clifford operators under conjugation by $T\in\mathcal{P}_{1}^{(3)}$ gates. Therefore, the output correction after applying a logical $T$ gate can be outside the Pauli frame.

In order to overcome these obstacles, we note that if error correction is performed immediately after the application of the $T$ gate, the output correction can be written as a logical Clifford gate $C$ times a Pauli matrix (a proof is presented in Appendix A).

If we were to keep track of the logical Clifford correction $C$ in classical software, it could propagate through the next $T$ gate, resulting in a correction involving even more $T$ gates. It could also propagate through a logical two-qubit gate (such as a CNOT) resulting in a two-qubit correction (the exact transformation rules are derived in Section 3). The two-qubit corrections could then propagate through other gates in the quantum algorithm leading to a generic Clifford correction. To prevent these scenarios from occurring, a buffer can be inserted right before the next logical two-qubit gate or $T$ gate part of the quantum algorithm. The role of the buffer is to learn what the Pauli frame was right before the application of the previous logical $T$ gate. During the buffer, repeated rounds of error correction are performed to prevent the accumulation of a large number of errors. There could be leftover Pauli corrections arising from error correction rounds which would only be known at a later time. However, by propagating the logical Clifford correction through the buffer, the Pauli corrections would remain Pauli.

Once the logical Clifford correction is propagated through the buffer, we apply a logical $C^{\dagger}$ thus restoring the Pauli frame. The protocol guarantees that only Pauli corrections would be propagated through the next logical $T$ or two-qubit gates. An illustration of the scheme is outlined in Fig. 2. As in [9], the proposed approach also effectively slows down gate times making them comparable to measurement times111Note that the buffer increases the overall time for implementing a non-Clifford gate. However, this impacts the overall running time of the quantum algorithm only by a constant factor.. However, buffers are only introduced when necessary and without having to increase the size of the code.

We conclude this section by noting that in [9, 18], the Pauli frame scheme was described in the context of concatenated codes where $T$ gates are implemented using state injection as shown in Fig. 3. In these schemes, a buffer is included to learn what the logical Pauli frame was before applying the $SX$ correction in order to correctly interpret the outcome of the $Z$-basis measurement. For instance, if a logical Pauli $X$ occurred on the data prior to implementing the $T$ gate, the Clifford correction $SX$ would be applied if the measurement outcome was $+1$ instead of $-1$ (see the caption of Fig. 3). Further, as was described in [9], additional layers of concatenation are required to prevent the build up of errors in the presence of quantum measurements with a long latency.

While it builds on the same general ideas, the Pauli frame scheme presented in this section is not restricted to a particular implementation of the $T$ gate (for instance, it also directly applies to codes which can implement a logical $T$ gate transversely) nor to concatenated schemes. In fact, our scheme slightly differs from [9, 18] even in the case where the $T$ gate is applied using state injection. Indeed, one does not wait to learn what the frame was before determining whether to apply the logical $SX$ correction (the $Z$-basis measurement outcome is always interpreted in the same way). The entire state injection circuit is completed before the Pauli frame (prior to the application of the state injection circuit) is known. Once it becomes known, one would know if the wrong logical $SX$ correction was applied and any remaining logical Clifford errors would be removed. So in particular, there is no need to introduce additional coding layers to slow-down the logical gate rate during this waiting time. While this is a fairly minor distinction, it does enable us to generalize to any other coding schemes and implementations of the $T$ gate, a feature which has not been addressed prior to our work.

3 Clifford frame

As was shown in [19], including Clifford corrections as part of the recovery protocol for error correcting codes that can implement logical Clifford gates transversely could significantly improve the code’s threshold for certain noise models. In fact, for coherent noise channels ($\mathcal{N}(\rho)=e^{i\bm{n}\cdot\bm{\sigma}}\rho e^{-i\bm{n}\cdot\bm{\sigma}}$ where $\bm{n}=(n_{x},n_{y},n_{z})$ with $||\bm{n}||=1$), it was shown that in some regimes the 5-qubit code (see [25]) can tolerate an arbitrary amount of coherent noise when Clifford corrections are used, while Pauli corrections have a finite threshold.

In this section, we extend the protocol used to cope with slow error-diagnostics to the case where error correction uses Clifford gates. When performing error correction on a set of encoded qubits with a stabilizer code, if one measures a non-trivial syndrome value $l$, a recovery map $R_{l}$ is applied to the data block. The recovery map can always be written in the form $R_{l}=\mathcal{L}({l})\mathcal{T}({l})\mathcal{G}({l})$ where $\mathcal{G}({l})\in\mathcal{P}_{n}^{(1)}$ is a product of stabilizer generators, $\mathcal{L}({l})$ is a product of logical operators and $\mathcal{T}({l})\in\mathcal{P}_{n}^{(1)}$ is a product of pure errors [26], see also Appendix A. Pure errors form an abelian group of operators that commute with all of the code’s logical operators and all but one of the codes stabilizer generators. The logical operators $\mathcal{L}({l})$ are chosen to maximize the probability of recovering the correct codeword – this is the decoding problem. The operators in the set $\mathcal{L}({l})$ are not necessarily restricted to logical Pauli operators as they can be extended to include all logical operators that can be applied fault-tolerantly.

It is thus natural to restrict $\mathcal{L}({l})$ to gates that can be applied transversally on the code. In particular, we will consider logical corrections in $(\mathcal{P}_{1}^{(2)})^{\otimes n}$, the group generated by $n$-fold tensor products of single-qubit Clifford operators. This latter group is generated by

[TABLE]

i.e., $\mathcal{P}^{(2)}_{1}=\langle H,S\rangle$. The order of the group is $|\mathcal{P}^{(2)}_{1}|=24$ (ignoring global phases). For the $n$-qubit case, $\mathcal{P}^{(2)}_{n}=\langle H_{i},S_{i},\mathrm{CNOT}_{ij}\rangle$ where the indices $i,j$ indicate which qubits to apply the Clifford gates. We point out that 2-D color codes [15] admit transversal realizations of all gates in $\mathcal{P}_{1}^{(2)}$. Furthermore, the 5-qubit code [27, 25] admits transversal realizations of logical gates in the set generated by $\langle SH,X,Z\rangle$.

For concatenated codes, we restrict the discussion to the case where logical Clifford corrections are performed at the last concatenation level only. If Clifford corrections were performed at every level, one would need to wait for the measurement outcomes of every level and actively perform Clifford corrections. This is because a level-$k$ logical Clifford correction does not generally commute with the level-($k+1$) syndrome measurements. The goal of defining a Clifford frame is to avoid actively correcting since the corrections themselves can introduce more errors into the computation.

We now derive the transformation rules for Clifford operators propagating through CNOT gates. Two-qubit controlled unitary gates $C\mbox{-}U_{12}|a\rangle|b\rangle=|a\rangle U^{a}|b\rangle$, where the first qubit is the control and the second qubit is the target, can be written as

[TABLE]

Note that from this definition $\mathrm{CNOT}_{12}=C\mbox{-}X_{12}$. Using Eq. 6, it is straightforward to show the following relations

[TABLE]

where we defined $U_{X}\equiv\frac{1}{2}(I+X)\otimes I+\frac{1}{2}(I-X)\otimes X$.

From Fig. 4 and Eqs. 7, 8, 9 and 10, it can be seen that propagating Clifford corrections through CNOT gates can result in both single and two-qubit Clifford corrections. By keeping track of logical Clifford corrections in classical software, these could grow due to other CNOT gates resulting in a generic Clifford correction. Furthermore, when propagating Clifford corrections through non-Clifford gates (such as the $T$ gate), the output can potentially be outside of the Clifford hierarchy. These could then propagate through the remainder of the logical circuit resulting in a unitary gate correction expressed as a product of several $T$ gates.

3.1 Clifford propagation through CNOT gates

We first address the propagation of logical Clifford corrections (expressed in tensor product form) through CNOT gates. The goal is to prevent a two-qubit correction from spreading to multiple code blocks in order to avoid performing a generic Clifford correction. After the application of a logical CNOT gate (as part of a quantum algorithm), we can place a buffer before the next logical two-qubit gate (or non-Clifford gate) in order to determine what the Clifford frame was right before the application of the logical CNOT. Note that during the application of the buffer, repeated rounds of error correction are performed to prevent the build-up of a large number of errors, producing additional Clifford gates.

From Eqs. 7, 8, 9 and 10, upon propagating the input Clifford gates $C_{1}\otimes C_{2}$ through a logical CNOT gate part of a quantum algorithm using a Clifford frame, two outcomes are possible. In the first case, we can have

[TABLE]

for some Clifford gates $C^{\prime}_{1}$ and $C^{\prime}_{2}$. In particular, we define

[TABLE]

If Eq. 11 is not satisfied for $C_{1}\otimes C_{2}$, then the output will belong to the set $C_{bad}$ defined to be

[TABLE]

where $\mathcal{P}_{2}^{(2)}$ is the two-qubit Clifford group. Performing a computer search, we found that out of the $24^{2}=576$ possible input Clifford gates (expressed in tensor product form), $64$ will satisfy Eq. 11.

After the application of the CNOT gate part of the quantum algorithm, the buffers will introduce the Clifford corrections $C_{3}\otimes C_{4}$ arising from the repeated rounds of error correction. Once the Clifford frame prior to applying the CNOT gate is known, we will be able to determine if the output from the propagation of the Clifford frame belongs to $C_{good}$ or $C_{bad}$. If it belongs to $C_{good}$, then no further operations are required. In the case where it belongs to $C_{bad}$, we perform a logical CNOT correction after the buffer. A second set of buffers is introduced to determine if the resulting gate belongs to $C_{good}$ or $C_{bad}$. We can repeat this process recursively until the resulting gate belongs to $C_{good}$.

Assuming the input Clifford gates and buffer Clifford corrections are chosen uniformly at random, we performed a simulation to estimate the transition probability from $C_{bad}\to C_{good}$. Performing $5\times 10^{5}$ simulations, we found that the $C_{bad}\rightarrow C_{good}$ transition occurs with probability $\frac{1}{12}$. Thus, when computing in a random Clifford frame, each logical CNOT requires on average $12+1$ logical CNOTs.

Lastly, we point out that for noise models where the Clifford corrections arising from the buffer are biased towards the Pauli gates, it would be more advantageous to apply $C^{\dagger}_{1}\otimes C^{\dagger}_{2}$ (where $C_{1}$ and $C_{2}$ are the input Clifford gates in Fig. 5(a)) after the following initial CNOT correction. More specifically, if the probability of acquiring a non-trivial Clifford correction in the buffer is $\epsilon$, then the $C_{bad}\rightarrow C_{good}$ transition probability becomes $1-\epsilon\frac{11}{12}$.

3.2 Clifford propagation through $T$ gates

We now address the propagation of Clifford corrections through a logical $T$ gate, which is a non-Clifford gate. When applying a logical $T$ gate in a quantum algorithm, we could also place a buffer before the next logical gate part of the quantum algorithm to learn the Clifford frame immediately before applying the $T$ gate. If the output correction is non-Clifford, we can perform appropriate corrections in order to restore the Clifford frame. If successful, this would guarantee that the input correction to the next gate would belong to the Clifford group.

Suppose the input to the logical $T$ gate is a Clifford correction $C_{1}$, so the resulting gate is $TC_{1}$. On the one hand, if $TC_{1}=\tilde{C}_{1}T$ for some Clifford $\tilde{C}_{1}$—or equivalently $TCT^{\dagger}\in\mathcal{P}^{(2)}_{1}$—then no further operations are necessary. Only gates in the set generated by $C_{1}\in\langle S,X\rangle$ satisfy this property. In fact, if $C_{1}\in\langle S,X\rangle$, then $TC_{1}T^{\dagger}\in\langle S,X\rangle$. Thus, we define

[TABLE]

Note that $|C_{-}|=8$ while $|C_{+}|=24-8=16$. Once we learn that the input Clifford correction $C_{1}$ to the logical $T$ gate belongs to $C_{-}$, then no further operations are necessary to restore the Clifford frame. If the buffer Clifford operations are uniformly distributed over the Clifford group, this occurs with probability $\frac{1}{3}$.

On the other hand, when we learn that the input Clifford correction $C_{1}$ to the logical $T$ gate belongs to $C_{+}$, we apply another logical $T$ in the hope to restore the Clifford frame. Since an additional Clifford gate $C_{2}$ was accumulated during the buffer, the resulting gate is $TC_{2}TC_{1}$. When $C_{2}\in C_{-}$, then $TC_{2}TC_{1}=\tilde{C}_{2}T^{2}C_{1}\in\mathcal{P}_{1}^{(2)}$, since $T^{2}=S$ is a Clifford transformation. At this stage, we have returned to a Clifford frame, but have removed the desired logical $T$ gate: we are thus back at our starting point and can try anew.

Once again, whenever the Clifford corrections occurring during the buffer are biased to the Pauli group (e.g., when the probability of an error is low), before applying another $T$ gate correction to restore the algorithm $T$ gate, we should apply the Clifford transformation $(\tilde{C}_{2}SC_{1})^{\dagger}$. In this way, we would increase the probability of being in a state of the form $CT$ where $C\in C_{-}$ (thus restoring the Clifford frame). To take this possibility into account, we will henceforth assume that the Clifford corrections arising from the buffer belong to $C_{-}$ with probability $1-p$ and to $C_{+}$ with probability $p$.

Define $\mathcal{T}^{(0)}=\mathcal{P}_{1}^{(2)}$ to be the set of single-qubit Clifford gates, and define

[TABLE]

Every time we learn that the previous buffer Clifford was in $C_{+}$, we apply a $T$ gate and wait for another buffer. Since this buffer will belong to $C_{-}$ with probability $1-p$ and to $C_{+}$ with probability $p$, each step of the above protocol can be seen as a step in a random walk over the sets $\mathcal{T}^{(k)}$ with transition $\mathcal{T}^{(k)}\rightarrow\mathcal{T}^{(k+1)}$ occurring with probability $p$ and transition $\mathcal{T}^{(k)}\rightarrow\mathcal{T}^{(k-1)}$ occurring with probability $1-p$. Every time $\mathcal{T}^{(0)}$ is reached, there is a probability $1-p$ that a logical $T$ gate is successfully realized at the next step.

To summarize, when attempting to implement a logical $T$ gate starting in a Clifford frame $\mathcal{T}^{(0)}$, we either succeed with probability $1-p$ or end up applying a $\mathcal{T}^{(1)}$ gate with probability $p$. In the latter case, we enter a random walk over $k\in\mathbb{N}$, and our goal it to return to $k=0$. This clearly requires an odd number of steps. The one-step process $1\rightarrow 0$ occurs with probability $1-p$. The three step process $1\rightarrow 2\rightarrow 1\rightarrow 0$ occurs with probability $p(1-p)^{2}$. Generalizing to $t=2j+1$ time steps, where $j\in\mathbb{N}$, the number of paths that lead to a gate in $\mathcal{T}^{(0)}$ is given by the $j$’th Catalan number $K_{j}=\frac{1}{j+1}\binom{2j}{j}$ [28]. Therefore, the probability of returning to a gate in $\mathcal{T}^{(0)}$ after $t=2j+1$ time steps is given by

[TABLE]

Using the generating function for the Catalan number $c(x)=\sum_{j\geq 0}K_{j}x^{j}=(1-\sqrt{1-4x})/(2x)$, the total probability that the random walk terminates is given by

[TABLE]

If $p>1/2$, then with finite probability the random walk will not terminate whereas if $p\leq 1/2$, the random walk is guaranteed terminate. This means that we must choose Clifford gates from $C_{-}$ with probability greater than $1/2$. The latter condition can be satisfied in cases where Clifford corrections arising from the buffer are biased towards gates belonging to $C_{-}$, or in particular if they are biased towards Pauli gates or the identity. When the buffers are chosen uniformly over the Clifford group, then $p=16/24=2/3>1/2$ so with some finite probability the procedure will not terminate.

We conclude this section by calculating the probability of obtaining a gate in $\mathcal{T}^{(0)}$ within $n$ time steps, which we define as $F(p,n)$. This quantity gives the number of expected $T$ gate corrections that need to be applied in order to restore the Clifford frame after propagation through a logical $T$ gate. The probability $F(p,n)$ is obtained by summing Eq. 16 with a cut-off of $n$ time-steps. The result is given by

[TABLE]

where

[TABLE]

and ${}_{2}F_{1}(a,b;c;z)$ is the Hypergeometric function defined in [29]. Plots of Eq. 18 are given in Fig. 6.

We now obtain an upper bound on the number of time steps $n$ that are necessary to restore the Clifford frame with probability $q=1-\epsilon$. In other words, we would like to obtain an upper bound on $n$ such that $F(p,n)>1-\epsilon$. We first obtain a lower bound for the function $f(p,n)$ by using the following inequalities

[TABLE]

[TABLE]

Inserting Eqs. 20 and 21 into Eq. 18, we obtain

[TABLE]

Setting $F(p,n)>1-\epsilon$, we obtain

[TABLE]

For $n\geq 1$, we have $1/(n+2)>(\frac{1}{2})^{n+1}$, so Eq. 23 becomes

[TABLE]

which shows that $n\sim|\log{\epsilon}|$—the $T$ gate overhead for restoring the Clifford frame scales logarithmically in $\epsilon$.

We now consider regimes where the noise is below the fault-tolerance threshold of a code (say $p\lesssim 10^{-2}$ as is required for the surface code [10]). In such regimes, corrections based on syndrome measurement outcomes will be significantly biased towards the identity, or more generally towards Pauli operators. More specifically, suppose that for a given noise model and code, a Pauli correction leads to a logical error rate $\delta_{P}$. Applying Clifford corrections can only improve this logical error rate to $\delta_{C}\leq\delta_{P}$ since they include Pauli corrections. But in a Clifford correction scheme, non-Pauli corrections are only used when Pauli corrections are not optimal, which occurs at a rate $\delta_{P}$, which is small below threshold. Consequently, in the case where a correction from $C_{bad}$ was applied, the expected number of $T$ gate corrections to return to the Clifford frame (as shown in Fig. 6) would be very close to one since $p\lesssim\delta_{P}$. Thus, we conclude that the Clifford gates can be used with the scheme proposed here at a negligible cost.

We conclude this section by mentioning that Clifford frames are also useful in randomized benchmarking schemes where random Clifford gates are applied to transform a given noise channel into an effective depolarizing channel [30, 31, 21]. In these schemes, once the random Clifford gates have been applied, they must be propagated in classical software through a sequence of logical gates that are part of the quantum circuit of interest (which typically includes Clifford and $T$ gates) and conjugate Clifford gates are subsequently applied after the Clifford frame has been restored. The techniques presented in this section can be used to restore the Clifford frame after propagation through the logical gates and could thus be an attractive approach for performing randomized benchmarking using Clifford gates. Note that if only random Pauli operators were used, the noise would be transformed to a Pauli channel (but not in general a depolarizing channel).

4 Conclusion

In this paper, we considered performing fault-tolerant quantum computation when measurement times and/or decoding times are much slower than gate times.

This was realized by providing a new scheme for performing error correction using the Pauli frame by placing buffers after the application of a non-Clifford gate. We showed that the Pauli frame can always be restored by applying logical Clifford corrections prior to the application of the next two-qubit or non-Clifford gate part of a quantum algorithm.

Given that logical Clifford corrections can significantly increase a code’s threshold value [19], in the remainder of the manuscript, we showed how to perform fault-tolerant error correction in the Clifford frame. We performed an in-depth study of the propagation of logical Clifford corrections through logical CNOT and $T$ gates, and the same idea can be generalized to other universal gate sets.

For the propagation through CNOT gates, we placed buffers at strategic locations to ensure that the output Clifford corrections could be expressed in tensor product form. To achieve this, we found that on average 12 logical CNOT corrections would be required when Clifford corrections arising from buffers are chosen uniformly at random. This ensures that two-qubit Clifford corrections would not propagate through the remainder of the circuit yielding a generic Clifford correction.

We also used buffers to keep track of the Clifford corrections propagating through $T$ gates. We showed that in certain conditions, by applying enough $T$ gate corrections, the Clifford frame could be restored with probability arbitrarily close to 1. Furthermore, to restore the Clifford frame with probability at least $1-\epsilon$, we showed that the number of $T$ gate corrections scales as $\log{(1/\epsilon})$.

While [19] has shown that Clifford corrections can produce a higher error threshold, the impact and applicability of Clifford corrections remains largely unexplored. Our original motivation for the current work was to determine if one of the key tricks used in FT schemes — Pauli frames — could be generalized to Clifford corrections. Having found that it can indeed be generalized at a negligible cost below threshold, we pave the way to future investigations of Clifford corrections.

5 Acknowledgements

We thank Tomas Jochym-O’Connor and Daniel Gottesman for useful discussions. C. C. would like to acknowledge the support of QEII-GSST and to thank the Institut Quantique at the University of Sherbrooke for their hospitality where most of this work was completed. This work was supported by the Army Research Office contract number W911NF-14-C-0048.

Appendix A Error correction for input Clifford errors

In this appendix we will explain why a generic $n-$qubit Clifford error on an encoded state transforms into a logical Clifford operation and a physical Pauli operation, upon doing stabilizer measurements.

Before proceeding, we provide a few definitions. Let $\bar{\rho}$ be an encoded state of a stabilizer code with stabilizer $\mathcal{S}$, that undergoes an error described by some CPTP map $\mathcal{E}$, i.e, $\bar{\rho}\mapsto\mathcal{E}(\bar{\rho})$. Let $\Pi_{0}$ denote the projector onto the code space and consequently $\Pi_{s}$ denote the projector onto the syndrome space of $s$. Let $T_{s}$ be a Pauli operation that takes a state from the syndrome $s$ subspace to the code space, i.e, $\Pi_{s}=T_{s}\cdot\Pi_{0}\cdot T_{s}$. Upon measuring the stabilizer generators to obtain a syndrome $s$ and applying the corresponding $T_{s}$ operation, the noisy state can be projected back to the code space,

[TABLE]

Since the resulting state is in the codespace, it can be decoded back to a single qubit state $\phi$, given by

[TABLE]

Let us denote the combined effect of the encoder, noise model, the projection to code space and the decoder by a quantum channel called the effective projection. The effective projection can be seen as acting directly on $\rho$ to result in $\phi$ [32].

However, in order to extract the (single qubit or logical) CPTP map defining the effective projection channel, we must make use of another tool, an isomorphism between channels and states, called the Choi-Jamiłowski isomorphism [33, 34]. Under this isomorphism, a single qubit CPTP channel $\mathcal{E}$ is mapped to a unique bipartite quantum state $\mathcal{J}(\mathcal{E})$ called the Choi matrix corresponding to $\mathcal{E}$, in the following manner.

[TABLE]

Furthermore, when the quantum channel is expressed as a process matrix $\Lambda$, where $\Lambda_{i,j}=\mathrm{Tr}\left(\mathcal{E}(P_{i})\cdot P_{j}\right)$, where $P_{i},P_{j}\in\{I,X,Y,Z\}$ are Pauli matrices, it follows that

[TABLE]

Lastly, note that when $\mathcal{E}(\rho)=C\cdot\rho\cdot C^{\dagger}$ where $C$ is a Clifford operation, the corresponding process matrix $\Lambda(\mathcal{E})$ is given by

[TABLE]

where $\sigma$ is a permutation of $\{1,2,3,4\}$ that depends on the Clifford operation. Hence the process matrix of a Clifford channel is a permutation matrix.

We now have all the necessary ingredients to prove our claim. Note that if $\rho$ in Eq. 25 is the Bell state and $\mathcal{E}$ acts on one half of the encoded Bell state, then using Eq. 27, we know that $\phi$ in Eq. 26 is simply the Choi matrix corresponding to the effective projection channel. From Eq. 28, it follows that the process matrix for the effective projection channel, denoted by $\Lambda^{(1)}$, is given by

[TABLE]

where $c_{k}\in\{+1,-1\}$ and in the last step, we have used the fact that $\Lambda$ is the process matrix of a Clifford operation, Eq. 29. That $\Lambda^{(1)}$ is also a permutation matrix follows from two properties – (i) Every row of $\Lambda^{(1)}$ has a unique non-zero column and (ii) every column of $\Lambda^{(1)}$ has a unique non-zero row. We will show (i) explicitly in what follows, the proof for (ii) is almost identical. Suppose that there are two columns $j^{\prime}$ and $j^{\prime\prime}$ such that $\Lambda_{ij^{\prime}}\neq 0$ and $\Lambda_{ij^{\prime\prime}}\neq 0$. Along with Eq. 30, it implies that there exists $P_{k^{\prime}}\in\bar{P}_{j^{\prime}}\cdot\mathcal{S}$ and $P_{k^{\prime\prime}}\in\bar{P}_{j^{\prime\prime}}\cdot\mathcal{S}$ such that $\delta_{l,\sigma(k^{\prime})}=\delta_{l,\sigma(k^{\prime\prime})}$. Hence, it must be that $\sigma(k^{\prime})=\sigma(k^{\prime\prime})$, in other words, $j^{\prime}=j^{\prime\prime}$.

Hence the effective projection channel is indeed a Clifford operation, in other words, any $n-$qubit Clifford operation on the physical qubits can be promoted to a logical Clifford operation and a physical Pauli error ($T_{s}$ in Eq. 25), by a syndrome measurement.