Fault-tolerant quantum error detection

We show the fault-tolerant encoding, measurement, and operation of a logical qubit via quantum error detection.

Abstract

Quantum computers will eventually reach a size at which quantum error correction becomes imperative. Quantum information can be protected from qubit imperfections and flawed control operations by encoding a single logical qubit in multiple physical qubits. This redundancy allows the extraction of error syndromes and the subsequent detection or correction of errors without destroying the logical state itself through direct measurement. We show the encoding and syndrome measurement of a fault-tolerantly prepared logical qubit via an error detection protocol on four physical qubits, represented by trapped atomic ions. This demonstrates the robustness of a logical qubit to imperfections in the very operations used to encode it. The advantage persists in the face of large added error rates and experimental calibration errors.

INTRODUCTION

The discovery of quantum error correction codes gave credibility to the idea of scaling up physical quantum systems to arbitrary sizes (1–3). Showing that all elements of error correction can be realized in a fault-tolerant way is therefore of fundamental interest. Fault tolerance removes the assumption of perfect encoding and decoding of logical qubits (4), because the logical error probability scales as a convex function of the physical error probability for small errors (5). Although several experiments have shown a reduction of high intrinsic or artificially introduced errors in logical qubits (6–14), fault-tolerant encoding of a logical qubit has never been demonstrated. We note that there are subtle issues with respect to the definition of fault tolerance that are beyond the scope of this paper.

Here, we implement a four-qubit error detection code with two stabilizers (see Fig. 1). This leaves two possible encoded qubits, L_a and L_b, for which errors can be detected: a [[4, 2, 2]] code (15, 16). The preparation and error detection procedures considered here are fault-tolerant on only a single encoded qubit. From a fault tolerance perspective, this is a [[4, 1, 2]] subsystem code where the logical qubit L_a is protected and the gauge qubit L_b is not. As such, the code was used in experiments with photonic qubits (17, 18). By instead considering errors on both encoded qubits, we highlight the importance of fault tolerance for reducing intrinsic errors and managing error propagation. The non–fault-tolerant procedures that generate L_b still succeed in reducing added errors.

Fig. 1. Graphical representation of the logical operators and stabilizers defining the [[4, 2, 2]] code on physical qubits 1 to 4.

The structure of the logical operators X and Z for the two encoded qubits L_a and L_b, and for the two stabilizers S_x and S_z, is defined in Eqs. 3 and 4.

The code implements L_a and L_b on only four physical qubits and hence violates the quantum Hamming bound (5), which means that detected errors cannot be uniquely identified and corrected. We must therefore rely on postselection to find and discard cases where an error occurred. The code does have the advantage of requiring only five physical qubits for the fault-tolerant encoding of L_a: four data qubits and one ancilla qubit.

The logical codewords |L_aL_b〉_L in the computational or Z-basis are

$${|00\rangle }_{\mathit{L}}=(|0000\rangle +|1111\rangle )/\sqrt{2}$$ (1A)

$${|01\rangle }_{\mathit{L}}=(|0011\rangle +|1100\rangle )/\sqrt{2}$$ (1B)

$${|10\rangle }_{\mathit{L}}=(|0101\rangle +|1010\rangle )/\sqrt{2}$$ (1C)

$${|11\rangle }_{\mathit{L}}=(|0110\rangle +|1001\rangle )/\sqrt{2}$$ (1D)

and with $|\pm \rangle =(|0\rangle \pm |1\rangle )/\sqrt{2}$, we can write them down along X as follows

$${|++\rangle }_{\mathit{L}}=(|++++\rangle +|----\rangle )/\sqrt{2}$$ (2A)

$${|+-\rangle }_{\mathit{L}}=(|+-+-\rangle +|-+-+\rangle )/\sqrt{2}$$ (2B)

$${|-+\rangle }_{\mathit{L}}=(|++--\rangle +|--++\rangle )/\sqrt{2}$$ (2C)

$${|--\rangle }_{\mathit{L}}=(|+--+\rangle +|-++-\rangle )/\sqrt{2}$$ (2D)

The encoding of different initial states is shown in Fig. 2 (A to D). The fault tolerance arises because the circuits for encoding and syndrome extraction are carefully constructed such that a single physical qubit error occurring anywhere cannot lead to an undetectable error on logical qubit L_a. It comes at the cost of the logical gauge qubit L_b, for which there is such an undetectable error channel. An example of this is shown in Fig. 2G.

Fig. 2. Circuit diagrams.

(A to D) Circuits for the encoding of four different logical states constructed such that logical qubit L_a is prepared fault-tolerantly. Any logical state can be achieved by applying single logical qubit operators to states encoded as shown here. (E and F) Circuits for the two stabilizers S_x and S_z, which project Z- and X-type errors, respectively, onto an ancilla qubit a. Note that a controlled Z-gate is realized by an inverted CNOT with the ancilla in the Z-basis as the target. (G) Example of fault-tolerant construction of circuits for logical qubit L_a: The encoding circuit for |00〉_L has a single nondetectable error channel. A bit-flip error E occurring as shown can change the state to |01〉_L, which is an error on the logical gauge qubit L_b. Logical qubit L_a is prepared fault-tolerantly. This property holds for all circuits (A to F).

With the Pauli operators X, Y, and Z and the identity I, the logical operators are

$${\mathit{Z}}_{\mathrm{a}}=\mathit{Z}\otimes \mathit{Z}\otimes \mathit{I}\otimes \mathit{I}$$ (3A)

$${\mathit{Z}}_{\mathrm{b}}=\mathit{Z}\otimes \mathit{I}\otimes \mathit{Z}\otimes \mathit{I}$$ (3B)

$${\mathit{X}}_{\mathrm{a}}=\mathit{X}\otimes \mathit{I}\otimes \mathit{X}\otimes \mathit{I}$$ (3C)

$${\mathit{X}}_{\mathrm{b}}=\mathit{X}\otimes \mathit{X}\otimes \mathit{I}\otimes \mathit{I}$$ (3D)

With these operators and the circuits given in Fig. 2 (A to D), any state |L_aL_b〉_L can be generated maintaining the fault tolerance of L_a.

The [[4, 2, 2]] code has the additional advantage that, in contrast to other codes (19), fault-tolerant syndrome extraction for the logical qubit L_a can be achieved using a bare ancilla, that is, an ancilla qubit that is not itself a logical qubit. The stabilizers to extract logical phase-flip (Z) and bit-flip (X) errors are S_x and S_z, respectively

$${\mathit{S}}_{\mathit{x}}=\mathit{X}\otimes \mathit{X}\otimes \mathit{X}\otimes \mathit{X}$$ (4A)

$${\mathit{S}}_{\mathit{z}}=\mathit{Z}\otimes \mathit{Z}\otimes \mathit{Z}\otimes \mathit{Z}$$ (4B)

As in a Bacon-Shor code block (20, 21), the code space together with the logical operators and stabilizers form a subsystem that allows local syndrome extraction similar to that of Napp and Preskill (22), as depicted in Fig. 1. The difference is that the stabilizers have weight 4 because we simultaneously extract information about the gauge qubit L_b. Applying these stabilizers conditional on the state of an ancilla qubit extracts the parity of the data qubits along X or Z (see Fig. 2, E and F). Measuring the ancilla yields either |0〉, indicating no error, or |1〉, meaning an error has occurred and the run is to be discarded. With only one ancilla qubit available, we measure the two stabilizers in separate experiments. Because we prepare eigenstates of logical Pauli operators, only logical Pauli operations that change the ideal state result in errors. Both stabilizer measurements serve to determine the overall yield, that is, the fraction of runs for which no error was indicated. In addition to the error checks provided by stabilizer measurements, only even-parity outcomes are accepted when the data qubits are measured at the end of the circuit. Note that similar weight 4 stabilizers have recently been implemented in superconducting qubits (23).

We implement the [[4, 2, 2]] code on a fully connected quantum computer comprising a chain of five single ¹⁷¹Yb⁺ ions confined in a Paul trap (see Materials and Methods). The state-detection fidelity for a single qubit is 99.7(1)% for state |0〉 and 99.1(1)% for state |1〉. A general five-qubit state is detected with 95.7(1)% fidelity. Single- and two-qubit gate fidelities are typically 99.1(5) and 97(1)%, respectively. Typical gate times are 20 and 250 μs for single- and two-qubit gates, respectively. The computational gates H and CNOT are generated by combining several physical-level single- and two-qubit gates in a modular fashion (24).

RESULTS

We start by preparing state |00〉_L using the circuit shown in Fig. 2A. The results of measuring this state directly after preparation are shown in Fig. 3A. The target states 0 (|00000〉) and 30 (|11110〉) show that we succeed in preparing and measuring this state with ≃90% probability. The data yield 91.1(4)% even-parity outcomes from the four data qubits. Breaking these results down by logical state gives 98.0(2)% population in the target state |00〉_L. The error falls almost entirely on |01〉_L, which corresponds to a 1.7(2)% error on the non–fault-tolerantly prepared gauge qubit L_b. The 0.11(6)% error exclusively on L_a is an order of magnitude lower than this, and at a similar level to the 0.18(7)% logical two-qubit error resulting in |11〉_L. For the logical state preparation step, both of these small erroneous state populations are dominated by physical readout errors.

Fig. 3. Results achieved with logical state |00〉_L.

(A) Results from the preparation of state |00〉_L. The abscissa represents the five-qubit states in decimal. We succeed in preparing (prep) and measuring the state with ~90% probability. The inset shows the result after postselection on the state being in the logical basis, that is, even parity. It is broken down by the logical state of the fault-tolerantly (FT) prepared qubit L_a and the non–fault-tolerantly (NFT) prepared qubit L_b. (B) Results of the stabilizer measurements after preparation of |00〉_L. The yields are 77.8(6) and 65.2(7)% for S_z and S_x, respectively. The insets show that the error probability on the fault-tolerantly prepared and stabilized logical qubit L_a is an order of magnitude below the non–fault-tolerantly prepared and stabilized qubit L_b.

With |00〉_L thus prepared, we apply in turn the two stabilizers S_z and S_x, shown in Fig. 2 (E and F), for nondemolition syndrome extraction. The results are shown in Fig. 3B. Populations in the odd-numbered states reflect events where an error is detected by a stabilizer. The results of the logical states are similar, with |00〉_L populations of 97.8(2) and 97.1(3)%, respectively, and the errors occur predominantly in the non–fault-tolerantly prepared gauge qubit L_b. The errors on L_a are 0.2(1)%, similar to the error floor given by the |11〉_L population, which is slightly higher than after mere state preparation due to the additional gates introduced by the stabilizers. S_x introduces X-type errors in the system, which can be seen from a higher L_b error. S_z introduces Z-type errors, which do not affect |00〉_L. The opposite is true when applying the stabilizers to |++〉 instead. Table 1 (see Materials and Methods) summarizes results for different logical states prepared with the circuits shown in Fig. 2 (A to D). The circuit elements that dominate the intrinsic errors in our system are the two-qubit gates. Note that after a circuit with seven CNOT gates, each of which introduces 3 to 4% infidelity, we obtain the correct answer |00〉_L with 97 to 98% probability. The gauge qubit L_b circuit failures occur at approximately the error rate of one two-qubit gate, whereas L_a errors are suppressed substantially below that level to <1%. These results show the power of fault-tolerant preparation and stabilizer measurement. The circuits succeed in discarding nearly all errors, but we pay a price because the yield is in the 65 to 75% range. We must expect to discard around half of the runs when measuring both stabilizers. The yield is higher for preparation of logical states without syndrome measurements because there are fewer gates to introduce error and there is only a single selection step.

Table 1. Probability distributions (in percentage) of measured logical states |L_aL_b〉 for various prepared logical states in each row, with and without stabilizers S_x or S_z applied.

The measurement basis is shown in the last column. The logical states are |00 > _L … |11 > _L, measured in the Z-basis, and | + + 〉_L … | − − 〉_L, measured in the X-basis. The very low error probability on the first logical qubit L_a compared to L_b shows the action of its fault-tolerant construction. We run every circuit 5000 to 6000 times. The results without stabilizer show the number of rejected runs from the parity check on the data qubits (typically ~8%) whereas the additional discard on the results with stabilizer (typically ~20%) is due to the ancilla result. The physical errors for state preparation and measurement are 0.3(1)% for states |0〉 and | + 〉, and 1.2(1)% for states |1〉 and | − 〉.

	Yield	Measured logical state |LaLb〉				Measurement basis
		|00〉	|01〉	|10〉	|11〉	Z
		| + + 〉	| + − 〉	| − + 〉	| − − 〉	X
|00〉L	91.1(4)	98.0(2)	1.7(2)	0.11(6)	0.18(7)	Z
|00〉LSz	77.8(6)	97.8(2)	1.7(2)	0.18(8)	0.3(1)	Z
|00〉LSx	65.2(7)	97.1(3)	2.4(3)	0.2(1)	0.3(1)	Z
| + + 〉L	91.1(4)	95.7(3)	3.9(3)	0.24(8)	0.22(8)	X
| + + 〉LSz	68.2(7)	93.0(5)	4.2(4)	1.3(2)	1.5(2)	X
| + + 〉LSx	72.1(6)	94.3(4)	4.5(4)	0.5(1)	0.7(2)	X
| − 1〉L	90.1(4)	0.22(8)	50.5(8)	0.09(6)	49.2(8)	Z
| − 1〉L	87.0(5)	0.3(1)	0.3(1)	50.4(8)	48.9(8)	X
| − 1〉LSz	79.9(6)	0.15(7)	50.0(8)	0.10(6)	49.8(8)	Z
| − 1〉LSz	75.5(6)	0.4(1)	0.3(1)	50.1(8)	49.2(8)	X
| − 1〉LSx	72.1(6)	0.6(1)	50.2(8)	0.5(1)	48.7(8)	Z
| − 1〉LSx	76.2(5)	0.4(1)	0.4(1)	50.0(7)	49.2(7)	X
|0 + 〉L	93.2(3)	47.4(5)	52.5(5)	0.06(3)	0.05(3)	Z
|0 + 〉L	92.4(4)	50.0(8)	0.04(4)	49.8(8)	0.09(5)	X
|0 + 〉LSz	81.6(6)	48.3(8)	51.4(8)	0.17(8)	0.17(8)	Z
|0 + 〉LSz	68.5(7)	47.1(9)	2.4(3)	47.4(9)	3.1(3)	X
|0 + 〉LSx	72.0(6)	48.3(8)	51.5(8)	0.16(7)	0.12(7)	Z
|0 + 〉LSx	70.9(7)	49.4(9)	0.4(1)	49.7(9)	0.5(1)	X
|11〉LSz	73.3(6)	0.4(1)	0.3(1)	2.8(3)	96.5(3)	Z

The [[4, 2, 2]] code allows transversal operations, that is, single-qubit logical gates that are generated by applying single-qubit physical gates. To show an example of this, we prepare |00〉_L followed by the logical X_aX_b operation consisting of X-gates on physical qubits 2 and 3. This gives |11〉_L, on which we apply the S_x stabilizer followed by readout. The yield is 77.3(6)%, and the logical state populations are as follows: |00〉_L, 0.4(1)%; |01〉_L, 0.3(1)%; |10〉_L, 2.8(3)%; and |11〉_L, 96.5(3)%. Apart from surpassing L_b as before, the L_a error of 0.7% also outperforms the physical qubit. We find that after an X-gate, the correct state of a physical qubit is measured with 98.8(2)% fidelity, nearly a factor of 2 worse than L_a. The infidelity in this case is dominated by the single-qubit detection error of 0.9(1)% for |1〉, which the code successfully suppresses in L_a.

To further investigate the robustness of the code, we add two kinds of error to the system. First, we deliberately introduce single- and two-qubit Pauli errors and study how errors on L_a and L_b scale with increasing physical qubit errors. Instead of trying to reproduce a stochastic error channel, which can be tedious for low error rates (25), we sample the various error configurations and then multiply them by their respective statistical importance to obtain a logical error probability (see Materials and Methods). We further compare our experimental results to an exact simulation with optimized error parameters (see Materials and Methods). The results are shown in Fig. 4A. The clear separation between the two logical qubits is persistent until they converge above 20% introduced error and approach the curve for the theoretical case without intrinsic errors. In this example, a physical qubit prepared in state |0〉 is outperformed by logical qubit L_a over the entire range, although our measurement uncertainty limits the significance of this to above p ~ 0.07%. L_b outperforms the physical qubit above 4% added error (solid black line in Fig. 4A). For state preparations |−〉 and |1〉, L_a also outperforms the physical error based on circuits of preparation and measurement, whereas for |+〉, the errors are consistent within statistical uncertainty (see Table 1).

Fig. 4. Performance of the code under different kinds of artificial errors.

(A) Logical error probability under artificially introduced stochastic Pauli errors. Uncertainties shown in gray with dashed outlines. We prepare state |00〉_L, introduce a specific error, and apply S_z before readout. The parameter values for the curves (see Materials and Methods) corresponding to the two logical qubits are determined either experimentally (solid lines) or from simulation (dashed lines). The black curve shows the limiting theoretical case without intrinsic errors (see Materials and Methods). At low added error rates, the intrinsic errors dominate, and the fault-tolerantly constructed qubit L_a starts about an order of magnitude below the non–fault-tolerantly constructed qubit L_b. With increasing inserted error probability, the added Pauli errors become dominant, and the L_a/b curves converge and approach the theory curve without intrinsic error. The solid black line shows the error rate for a single physical qubit. L_a results in a lower error across the entire range relative to the physical qubit, although our measurement uncertainty means that this is no longer significant below p ~ 0.07%. The L_b error is lower than the physical qubit for added errors >4%. (B and C) Preparing |00〉_L and measuring S_x/z with purposefully miscalibrated two-qubit gates, known as XX-gates. A miscalibration of α means that the Bell state produced by the gate is imbalanced: $\sqrt{0.5-\mathrm{\alpha }}|00\rangle +\mathit{i}\sqrt{0.5+\mathrm{\alpha }}|11\rangle$. The yields diminishing with miscalibration for the stabilizer measurements are shown in (B), whereas the errors on the logical qubits presented in (C) remain similar, with L_a errors about an order of magnitude lower than L_b errors.

Second, we run the |00〉_L data with purposefully miscalibrated two-qubit gates. The results for the logical errors are shown in Fig. 4C. The error gap of nearly an order of magnitude between L_a and L_b persists over a wide range of calibration errors, which are absorbed into a reduced yield as shown in Fig. 4B. This proves that the code succeeds in protecting qubit L_a against intrinsic systematic errors.

DISCUSSION

Note that the [[4, 2, 2]] code is relevant beyond its limited immediate application as an error detection code. It forms the base encoding layer of the high-threshold Knill C4/C6 code (26) and of a recent proposal for a topological code (27), and it is equivalent to one face of the distance 3 color code (28) or the Steane code (2). The code is robust to the high levels of intrinsic errors present in current realizations of quantum computers. We find no evidence of unexpected two-qubit correlated errors, which are always assumed absent when constructing error correction procedures. Therefore, our results both serve as a demonstration that this underlying model is correct and pave the way toward error-corrected quantum computations on a larger scale.

MATERIALS AND METHODS

Experimental system

The experiment was performed on a quantum computer consisting of a chain of five single ¹⁷¹Yb⁺ ions confined in a Paul trap and laser-cooled near the motional ground state. Each ion provided one physical qubit in the form of a pair of states in the hyperfine-split ²S_1/2 ground level with an energy difference of 12.642821 GHz, which is magnetic field–independent to first order. This so-called “atomic clock” qubit has a typical coherence time of 0.5 s, which could be straightforwardly extended by suppressing magnetic field noise. All qubits were collectively initialized by optical pumping and measured via state-dependent fluorescence detection (29). Each ion was mapped to a distinct channel of a photomultiplier tube array. Its state could be detected with 99.4(1)% average fidelity, although a five-qubit state was read out with 95.7(1)% average fidelity, limited by channel-to-channel cross-talk. Qubit manipulation was achieved by applying two Raman beams from a single 355-nm mode-locked laser, which formed beat notes near the qubit frequency. The first Raman beam was a global beam applied to the entire chain, whereas the second was split into individual addressing beams, each of which could be switched independently to target any single qubit (24). Single qubit gates were generated by driving resonant Rabi rotations of defined phase, amplitude, and duration. Two-qubit gates (so-called XX-gates) were realized by illuminating two ions with beat-note frequencies near the motional sidebands and creating an effective spin-spin (Ising) interaction via transient entanglement between the state of two ions and all modes of motion (30–32). To ensure that the motion was left disentangled from the qubit states at the end of the interaction, we used a pulse shaping scheme by modulating the amplitude of the global beam (33, 34).

Artificial stochastic errors

To analyze how the code copes with artificially introduced stochastic errors, we prepared logical state |00〉_L and added a specific Pauli error, for example, I ⊗ X ⊗ Y ⊗ I. We then applied the S_z stabilizer and measured the state. We repeated this for different error configurations ε. The error probability p on a physical qubit corresponds to an X, Y, or Z error, each occurring with probability p/3. The number of errors that appear in a particular error configuration is given by its weight w, and its probability of occurrence or statistical importance is p_o = (p/3)^w(1 − p)^4−w. The probability of a logical error is given by

$${\mathit{p}}_{\mathit{L}}=\frac{{\displaystyle {\sum }_{\mathrm{\epsilon }}}{\mathit{p}}_{\mathit{o}}(\mathrm{\epsilon })\cdot {\mathit{p}}_{\mathrm{a}}(\mathrm{\epsilon })\cdot {\mathit{p}}_{\mathrm{f}}(\mathrm{\epsilon })}{{\displaystyle {\sum }_{\mathrm{\epsilon }}}{\mathit{p}}_{\mathit{o}}(\mathrm{\epsilon })\cdot {\mathit{p}}_{\mathrm{a}}(\mathrm{\epsilon })}$$ (5)

The sum runs over all error configurations. p_a is the yield, that is, the probability that a run is accepted, and p_f is the probability of failure after postselection, that is, the probability that an accepted run suffers a logical error. The dividend is the number of accepted runs with a logical error, whereas the divisor is the number of accepted runs (both divided by the total number of runs). The parameters p_a and p_f were found from either experiment or simulation (see Fig. 4A). Out of the total number of error configurations, $\mathit{n}(\mathit{w})={\mathit{w}}^3\left(\begin{array}{c}4\\ \mathit{w}\end{array}\right)$. We covered the error configurations of weight 0 and 1 exhaustively. For the w = 2 subset, we only sampled 27 representative configurations out of the total 54 and doubled their weight. The weight 3 and weight 4 subsets were not sampled, and their logical error rates were set to zero, because their statistical importance is significant only at very high added error rates. In the limit of no intrinsic errors, that is, perfect gates, preparation, and measurement, both logical qubits had the same error rate under this model (dash-dotted line in Fig. 4A). We found this error rate from Eq. 5 by counting accepted error configurations with w ≤ 2 (denominator) and checking which of those caused an error (numerator).

$${\mathit{p}}_{\mathit{L}}^{*}=\frac{16{(1-\mathit{p})}^2{(\mathit{p}/3)}^2}{{(1-\mathit{p})}^4+4{(1-\mathit{p})}^3\mathit{p}/3+30{(1-\mathit{p})}^2{(\mathit{p}/3)}^2}$$ (6)

The dashed curves in Fig. 4A were obtained by performing a full density matrix simulation of the five-qubit circuits. We used a simplified error model to emulate experimental errors. The model had three independent parameters corresponding to errors associated with over- or underrotations after (i) single-qubit and (ii) two-qubit gates and (iii) phase errors caused by Stark shifts. An experimentally found state-transfer matrix was used to take state preparation and detection errors, including cross-talk, into account. We then optimized the model over the parameter space to minimize the difference between the final state populations of the experimental and simulated circuits. The resulting values for the error rates were 0.50, 1.0, and 1.4%, respectively.

The physical error curve in Fig. 4A is the straight line p_p = r + (2/3 F_x)p, where r = 0.003 is the readout error for a physical qubit in state |0〉. The slope is 2/3 F_x because one in three added errors is a Z-type error, which does not affect |0〉, and F_x = 0.997 is the success probability of a physical spin flip operation.