Realization of Real-Time Fault-Tolerant Quantum Error Correction

Correcting errors in real time is essential for reliable large-scale quantum computations. Realizing this high-level function requires a system capable of several low-level primitives, including single-qubit and two-qubit operations, midcircuit measurements of subsets of qubits, real-time processing of measurement outcomes, and the ability to condition subsequent gate operations on those measurements. In this work, we use a 10-qubit quantum charge-coupled device trapped-ion quantum computer to encode a single logical qubit using the $[[7,1,3]]$ color code, first proposed by Steane [Phys. Rev. Lett. 77, 793 (1996)]. The logical qubit is initialized into the eigenstates of three mutually unbiased bases using an encoding circuit, and we measure an average logical state preparation and measurement (SPAM) error of $1.7(2)\times {10}^{-3}$, compared to the average physical SPAM error $2.4(4)\times {10}^{-3}$ of our qubits. We then perform multiple syndrome measurements on the encoded qubit, using a real-time decoder to determine any necessary corrections that are done either as software updates to the Pauli frame or as physically applied gates. Moreover, these procedures are done repeatedly while maintaining coherence, demonstrating a dynamically protected logical qubit memory. Additionally, we demonstrate non-Clifford qubit operations by encoding a $\overline{T}|+{⟩}_L$ magic state with an error rate below the threshold required for magic state distillation. Finally, we present system-level simulations that allow us to identify key hardware upgrades that may enable the system to reach the pseudothreshold.

Popular Summary

Quantum computers promise to deliver exponential improvements over their classical counterparts, but only if researchers learn how to tame the noise and errors in the underlying logic operations. Fortunately, the discovery of quantum error codes showed that redundant encoding of quantum information into larger quantum systems allows for the exponential suppression of noise, thereby making large-scale quantum computations feasible. Here, we present the first experimental demonstration of a quantum error-correction code able to detect errors and fix them while a computation is taking place as well as demonstrate the ability to arbitrarily repeat such corrected quantum computation.

In our setup, we use seven trapped-ion qubits to encode a single logical qubit and three extra trapped-ion qubits to detect errors. A classical computer quickly processes measurements made by the three extra qubits to determine if the encoded qubit is in error. If it is, the classical computer assigns correction operations to fix the encoded qubit. Importantly, this interaction between the classical and quantum processors happens during run-time, and it finishes quickly compared to any process that might corrupt the encoded qubit further, thereby allowing the computation to proceed.

While our error rates are not yet below the level needed for useful quantum computations, detailed simulations of the experiment allow us to identify key sources of error, such as leakage and dephasing. The tools we develop can provide a guide for mitigating those errors, thereby paving the way for truly large-scale quantum computations.

Figure 1

The $[[7,1,3]]$ color code. Physical qubits are indicated by white circles. The seven data qubits are on the vertices of the polygons, and three ancilla qubits for syndrome measurements in the center of each polygon. For each polygon, the four qubits at the vertices define both $X$-type and $Z$-type stabilizer measurements used in each error correction cycle. The stabilizer generators and logical operators are tensor products of single-qubit Paulis with support indicated by the physical qubit subscript index. For example, implementing the logical $\overline{Z}$ operation is done with physical layer $Z$ operations on qubits 5, 6, and 7. Likewise, measuring $\overline{Z}$ is done by measuring $Z_5{Z}_6{Z}_7$ where the logical qubit measurement outcome is the product of the three individual physical qubit measurement outcomes. Although not shown, $Y$-type stabilizers are generated by the $X$- and $Z$-type stabilizers listed here.

Figure 2

The ion trap loaded with ten ${}^{171}{\mathrm{Yb}}^{+}$ qubit ions (red circles) and ten ${}^{138}{\mathrm{Ba}}^{+}$ coolant ions (white circles). The trap has different functional regions, or zones, with functions determined by the electrode geometry and laser beam configuration. Ion transport is used to arrange ions into zones for gates and measurements. The electrodes in red and blue denote regions that support transport operations, including linear transport, crystal split and combine, and physical swap. The green regions support linear transport and storage of ions between gating operations. The three regions where qubit initialization, gating, and measurement occur are marked by the crossing laser beams. In the gray region ions are loaded from an effusive atomic oven behind the trap using photoionization.

Figure 3

A schematic of the QEC experiment. Here the steps taken in a QEC experiment are outlined including repeat-until-success initialization of a $|0{⟩}_L$ state, the logical rotation of the state, conditional branching taken to perform syndrome extraction fault tolerantly, decoding, the destructive logical measurement, and the determination of a logical measurement output. An extended version of this figure, which includes circuit diagrams, can be found in Fig. 10.

Figure 4

Comparing the observed logical fidelities of the six logical Pauli basis states over many QEC cycles. Averages and standard deviations were determined by jackknife resampling between individual experiments [68]. The large points with error bars are experimental averages and standard deviations. The smaller and lighter points are individual trials for a given QEC cycle experiment. Note that for 0 QEC cycles, numerous experimental trials have an error rate of 0 and, thus, are not displayed due to the log scale. The lines are fits to the experimental averages, where the fits are exponential decay curves $p_L(c)=0.5+(p_{\mathrm{SPAM}}-0.5){(1-2p_{\text{cycle}})}^c$ (see Appendix pp2 for derivation). Here $p_L(c)$ is the logical error rate of a cycle $c$ and logical basis $L$, $p_{\mathrm{SPAM}}$ the logical SPAM error, and $p_{\text{cycle}}$ is the logical QEC cycle error. Note that $p_{\mathrm{SPAM}}$ is determined directly from the 0 QEC cycle results and fixed when determining the fits. Thus, from the fits, we obtain estimates of $p_{\text{cycle}}$. The values of $p_{\mathrm{SPAM}}$ and $p_{\text{cycle}}$ are reported in Table 3.

Figure 5

Comparing the observed and simulated logical fidelities of the logical Pauli bases. Averages and standard deviations were determined by combining the data of both basis states of a given basis and using jackknife resampling between individual experiments [68]. The large points with error bars are experimental averages and standard deviations. The smaller and lighter points are individual trials for a given QEC cycle experiment. Note that for 0 QEC cycles, numerous experimental trials have an error rate of 0 and, thus, are not displayed due to the log scale. The lines are fits to the simulated and experimental averages, where the fits are exponential decay curves $p_L(c)=0.5+(p_{\mathrm{SPAM}}-0.5){(1-2p_{\text{cycle}})}^c$ (see Appendix pp2 for derivation). Here $p_L(c)$ is the logical error rate of a cycle $c$ and logical basis $L$, $p_{\mathrm{SPAM}}$ the logical SPAM error, and $p_{\text{cycle}}$ is the logical QEC cycle error. Note that $p_{\mathrm{SPAM}}$ is determined directly from the 0 QEC cycle experiments and fixed when determining the fits. Thus, from the fits, we obtain estimates of $p_{\text{cycle}}$. The values of $p_{\mathrm{SPAM}}$ and $p_{\text{cycle}}$ are reported in Table 4.

Figure 6

The logical qubit error budget. The pie chart shows the percent contribution to the logical QEC cycle error rate from the physical noise due to SPAM and MCMR, unitary gates, and qubit dephasing. $A$ and $B$ are the vector and matrix in Eq. (5) and the elements are ordered as {SPAM and MCMR, gates, dephasing}. The individual contributions in the pie chart indexed by $i$ are calculated as $(A_i+{\sum }_j{B}_{ij})/({\sum }_i{A}_i+{\sum }_{ij}{B}_{ij})$.

Figure 7

Comparison of the logical error rate to different error models as the physical error rates are scaled. The dashed line is equal to the physical layer two-qubit depolarizing error rate, $p2$, times the scaling factor defining the $x$ axis, which we use to define our pseudothreshold line. The four solid lines represent the logical qubit error rate for different simulated error model scenarios. They are plotted as a function of an overall scaling of the error model parameters. The red line (circles) uses our current error model parameters estimate, which are detailed in Table 6; the blue line (triangles) was generated assuming our current error parameters except with the dephasing rate being reduced by $10\times$; the green line (squares) was generated assuming our current error parameters except with the leakage rate being reduced by $10\times$; the purple line (stars) was generated by starting with our current error parameters and suppressing both the dephasing and the leakage rates by $10\times$. The vertical dotted line ($x=1/3$) is approximately where the purple line crosses the pseudothreshold. We find that reducing the leakage will be key to achieving a QEC cycle logical error rate below pseudothreshold (when the logical error rate is less than the leading physical error rate). Note that some error bars are smaller than the markers.

Figure 8

Comparing the observed logical error rates for both uncorrected and corrected logical bases results over many QEC cycles. Averages (points) and standard deviations (error bars) were determined by jackknife resampling between individual experiments [68]. The lines are fits to the experimental averages, where the fits are exponential decay curves $p_L(c)=0.5+(p_{\mathrm{SPAM}}-0.5){(1-2p_{\text{cycle}})}^c$ (see Appendix pp2 for derivation). Here $p_L(c)$ is the logical error rate of a cycle $c$ and logical basis $L$, $p_{\mathrm{SPAM}}$ the logical SPAM error, and $p_{\text{cycle}}$ is the logical QEC cycle error. Note that $p_{\mathrm{SPAM}}$ is determined directly from the 0 QEC cycle results and fixed when determining the fits.

Figure 9

Comparing the circuit path taken through the QEC cycles. Data averages and standard deviations were determined by jackknife resampling between individual experiments [68]. Horizontal dotted lines correspond to the probability of taking the indicated path after combining the data regardless of number of QEC cycles. Labels A, B, and C are defined in Appendix pp3.

Figure 10

A detailed schematic of the QEC demonstration. The encoding circuit first prepares $|0{⟩}_L$ and uses an ancilla to verify this preparation. If the ancilla measured is found in $|0⟩$, the circuit succeeded and moves to the next step. If the ancilla is found to be in $|1⟩$, then all qubits are reinitialized and the circuit ran again until successful, up to 3 times. After a maximum of three initialization attempts, we proceed by applying single-qubit unitaries to make a logical rotation to prepare the desired logical state. Adaptive QEC cycles are then performed. The first set of three syndromes is measured using the flag circuit $\{S_1^f,S_5^f,S_6^f\}$. If these syndromes do not indicate an error, then the second set of three syndromes is measured $\{S_1^f,S_3^f,S_4^f\}$, and if no errors are indicated, the syndrome extraction protocol is complete. If either of the flagged circuits does indicate an error, the protocol moves to measure all six stabilizers using the unflagged circuit $\{S_1,S_2,S_3,\dots \}$, thus completing the syndrome extraction. The syndrome information is then fed to the decoder to infer a correction, and the Pauli frame is updated. Finally, the state is rotated to the appropriate basis for measurement using single-qubit unitaries. Upon measurement, syndrome information is inferred and sent to the decoder for a final correction.

Figure 11

An outline of the decoder procedure and two different error configurations. (a) A single-qubit hook error occurs on an ancilla and spreads to two data qubits. This triggers the additional round of syndrome extraction using the unflagged circuits. We denote the errors on the data qubits (gray circles) and the changed syndrome measurements (black circles) pictorially on the color code figure. (b) A single-qubit error occurs on a data qubit and causes a change in the syndrome measurements, again triggering an additional round of syndrome extraction. In both (a) and (b) the final round of syndrome measurements are identical, meaning the first step of the decoder cannot distinguish between these two error configurations. The second step of the decoder compares the syndromes measured within the QEC cycle to distinguish between cases such as this. We see that the two sets of measured syndromes are different for the hook error but the same for the single-qubit data error.

Figure 12

A schematic of the $\overline{S}$ gate experiments. In this set of experiments, we compare physically applied corrections to implementing the corrections in software using the Pauli frame. The main elements are the same as those used in Fig. 10. First, using the FT encoding circuit, we prepare $|0{⟩}_L$ and rotate to $|+{⟩}_L$ with an $\overline{H}$ gate. We then perform one QEC cycle to generate corrections. Next, we either physically apply corrections to the qubits or update the Pauli frame in software, followed by physically applying the $\overline{S}$ gate. We then apply one last QEC cycle to generate further corrections, rotate to the $\overline{Y}$ basis, and measure the data qubits. The final corrective steps infer the syndromes, decode, and apply corrections to the output data as outlined in the main text and Fig. 10.

Figure 13

A non-fault-tolerant encoding circuit used to prepare the magic state $\overline{T}|+{⟩}_L$.

Figure 14

The main program for the repeated QEC cycle and the magic state experiment.

Figure 15

The main program for the active versus software correction experiment with the logical $S$.

Figure 16

Rotate logical $|0⟩$ to the appropriate state.

Figure 17

A QEC cycle.

Figure 18

Rotate measurement to the correct logical basis.

Figure 19

A measurement in the logical $Z$ basis.

Figure 20

Determining if the result is expected.

Figure 21

The basic 2D decoder that infers if a logical error has occurred.

Figure 22

An additional decoder that updates the correction based on flag information.