Fault Tolerance with Bare Ancillae for a [[7,1,3]] Code

TL;DR

This paper introduces a [[7, 1, 3]] quantum error-correcting code that achieves fault-tolerance with minimal ancillae under certain realistic noise models, and proposes enhancements for more general errors.

Contribution

It demonstrates fault-tolerant syndrome measurement using one ancilla per stabilizer for specific error models and proposes flag qubits to handle depolarizing errors.

Findings

One ancilla per stabilizer suffices under anisotropic errors.

Additional flag qubits are needed for depolarizing errors.

Physically motivated noise models can simplify fault-tolerance protocols.

Abstract

We present a [[7, 1, 3]] quantum error-correcting code that is able to achieve fault-tolerant syndrome measurement using one ancillary qubit per stabilizer for an error model of independent single-qubit Pauli errors. All single-qubit Pauli errors on the ancillary qubits propagate to form exclusively correctable errors on the data qubits. The situation changes for error models with two-qubit Pauli errors. We compare the level-1 logical error rates under two noise models: the standard Pauli symmetric depolarizing error model and an anisotropic error model. The anisotropic model is motivated by control errors on two-qubit gates commonly applied to trapped ion qubits. We find that one ancillary qubit per syndrome measurement is sufficient for fault-tolerance for the anisotropic error, but is not sufficient for the standard depolarizing errors. We then show how to achieve fault tolerance for the standard depolarizing errors by adding flag qubits to check for errors on select ancilary qubits. Our results on this [[7, 1, 3]] code demonstrates how physically motivated noise models may simplify fault-tolerent protocols.

Tables

Table 1. Table 1 : List of stabilizers and logical operators X L , Z L subscript 𝑋 𝐿 subscript 𝑍 𝐿 X_{L},\,Z_{L} for the Bare [ [ 7 , 1 , 3 ] ] delimited-[] 7 1 3 [[7,1,3]] code.

Stabilizer Generators	Logical Operators
$X_0{X}_4$
$X_1{X}_4$
$X_2{X}_5$	$X_L=X_1{X}_2{X}_3$
$X_3{X}_6$	$Z_L=Z_0{Z}_1{Z}_4$
$Z_2{Z}_3{Y}_5{Y}_6$
$Z_0{Z}_1{Z}_2{X}_3{Z}_4{Z}_5$

Table 2. Table 2 : Single-qubit error syndromes for the Bare [ [ 7 , 1 , 3 ] ] delimited-[] 7 1 3 [[7,1,3]] code.

$Z_0\to 100000$	$X_0\to 000001$	$Y_0\to 100001$
$Z_1\to 010000$	$X_1\to 000001$	$Y_1\to 010001$
$Z_2\to 001000$	$X_2\to 000011$	$Y_2\to 001011$
$Z_3\to 000101$	$X_3\to 000010$	$Y_3\to 000111$
$Z_4\to 110000$	$X_4\to 000001$	$Y_4\to 110001$
$Z_5\to 001010$	$X_5\to 000011$	$Y_5\to 001001$
$Z_6\to 000110$	$X_6\to 000010$	$Y_6\to 000100$

Table 3. Table 3 : The nontrivial data errors that can result from a single two-qubit error for the stabilizer Z 2 ​ Z 3 ​ Y 5 ​ Y 6 subscript 𝑍 2 subscript 𝑍 3 subscript 𝑌 5 subscript 𝑌 6 Z_{2}Z_{3}Y_{5}Y_{6} (Figure 4(a) ) and trigger the flag qubit measurement. The errors marked in red can lead to logical errors with the bare method.

b errors	Data error	syndrome	c errors	Data error	syndrome
$IX$	$Y_5{Y}_6$	$001101$	$IX$	$Y_6$	$000100$
$XX$	$X_3{Y}_5{Y}_6$	$001111$	$XX$	$X_5{Y}_6$	$000111$
$YX$	$Y_3{Y}_5{Y}_6$	$001010$	$YX$	$Y_5{Y}_6$	$001101$
$ZX$	$Z_3{Y}_5{Y}_6$	$001000$	$ZX$	$Z_5{Y}_6$	$001110$

Table 4. Table 4 : The nontrivial data errors that can result from a single two-qubit error for the stabilizer Z 0 ​ Z 1 ​ Z 2 ​ X 3 ​ Z 4 ​ Z 5 subscript 𝑍 0 subscript 𝑍 1 subscript 𝑍 2 subscript 𝑋 3 subscript 𝑍 4 subscript 𝑍 5 Z_{0}Z_{1}Z_{2}X_{3}Z_{4}Z_{5} (Figure 4(b) ) and trigger the flag qubit measurement. The errors marked in red can lead to logical errors with the bare method.

b errors	Data error	syndrome	c errors	Data error	syndrome
$IX$	$Z_1{Z}_2{Z}_4{Z}_5$	$100010$	$IX$	$Z_1{Z}_2{Z}_5$	$010010$
$XX$	$Z_1{Z}_2{X}_3{Z}_4{Z}_5$	$100000$	$XX$	$Z_1{Z}_2{X}_4{Z}_5$	$010011$
$YX$	$Z_1{Z}_2{Y}_3{Z}_4{Z}_5$	$100101$	$YX$	$Z_1{Z}_2{Y}_4{Z}_5$	$100011$
$ZX$	$Z_1{Z}_2{Z}_3{Z}_4{Z}_5$	$100111$	$ZX$	$Z_1{Z}_2{Z}_4{Z}_5$	$100010$
d errors	Data error	syndrome	e errors	Data error	syndrome
$IX$	$Z_1{Z}_5$	$011010$	$IX$	$Z_5$	$001010$
$XX$	$Z_1{X}_2{Z}_5$	$011001$	$XX$	$X_1{Z}_5$	$001011$
$YX$	$Z_1{Y}_2{Z}_5$	$010001$	$YX$	$Y_1{Z}_5$	$011011$
$ZX$	$Z_1{Z}_2{Z}_5$	$010010$	$ZX$	$Z_1{Z}_5$	$011010$

Equations

$$p_L(p_s,p_t)=\sum _{s,t}{A}_{s,t}(p_s,p_t)p_L(s,t),$$

$$p_L=\sum _{i=0}^{N_c}{A}_i{p}_i,$$

$$A_{s,t}(p_s,p_t)=\left(\genfrac{}{}{0ex}{}{n_s}{s}\right)p_s^s(1-p_s{)}^{n_s-s}(\genfrac{}{}{0ex}{}{n_t}{t})p_t^t(1-p_t{)}^{n_t-t}.$$

$$p_L(p_s,p_t)=\sum _{s,t}{A}_{s,t}(p_s,p_t)p_L(s,t),$$

Full text

quantum error correction; quantum computing

I Introduction

The operation of a universal quantum computer requires protocols to protect it from instrumental and environmental imperfections. Quantum error-correcting (QEC) Shor (1995) codes are among the most promising approaches to deliver scalable and reliable fault-tolerant quantum computation. Topological QEC codes have a two-dimensional qubit layout that limits qubit interactions to only nearest neighbors, which is suitable for practical implementation using quantum architectures such as superconducting devices and trapped ions Raussendorf and Harrington (2007); Fowler et al. (2009); Yoder and Kim (2017). Concatenated codes require more resources to be mapped onto local architectures, but can use less resources overall than topological codes for low error rate systems Svore et al. (2007). In general, the optimal choice of quantum error-correcting code is dependent on the actual noise environment and the quantum circuit being used Suchara et al. (2013). Many QEC codes, both topological codes and concatenated codes, belong to the family of Calderbank-Shor-Steane (CSS) codes, where $X$ and $Z$ Pauli errors can be treated separately Steane (1996a); Calderbank and Shor (1996).

For a given QEC code, different methods of syndrome measurement, state preparation and decoding can all affect the resulting logical error rate. For syndrome measurement, using a single (bare) ancillary qubit to measure a stabilizer is in general not fault-tolerant, since errors on the ancillary qubit can propagate to the data and form uncorrectable errors Nielsen and Chuang (2010); Preskill (1998). Although there are various methods to make the syndrome measurement fault-tolerant, these come at the expense of extra resources. Shor’s method requires a $w$-qubit cat state to measure a weight-$w$ stabilizer Shor (1996). An extra qubit is needed to verify the ancillary qubit, but this is not a strict requirement DiVincenzo and Aliferis (2007); Tomita et al. (2013). Steane’s method requires the fault-tolerant preparation of a logical state Steane (1997), while Knill’s method relies on the fault-tolerant preparation of a logical Bell pair Knill (2005).

Using bare ancillary qubits for stabilizer measurement can be fault-tolerant if we are guaranteed that single-qubit errors or errors that occur with a probability linearly proportional to the physical error rate do not propagate to form uncorrectable errors. More specifically, if we assume only Pauli errors, then after measuring a stabilizer of weight $w$ a weight $\lfloor w/2\rfloor$, where $\lfloor x\rfloor$ is the floor of $x$, error can propagate to the data. This can still be fault-tolerant in several cases. In some codes, the presence of gauge subsystems allow the decomposition of high weight stabilizers into lower weight gauge operators that can be measured in a fault-tolerant fashion using bare ancillary qubits. This is the case of the Bacon-Shor codes Bacon (2006); Aliferis and Cross (2007). In other cases, codes have a large enough distance such that any error of weight up to $\lfloor w/2\rfloor$ can be corrected ($d\geq 2\lfloor w/2\rfloor+1$). This is the case of large distance surface Fowler et al. (2009, 2012) and color codes Bombin and Martin Delgado (2006); Landahl et al. (2011). Finally, certain codes with distance $d<2\lfloor w/2\rfloor+1$ allow for stabilizer measurement with bare ancillary qubits because the resulting errors on data qubits are correctable. This is the case for the $[[9,1,3]]$ surface code, where the weight-$2$ errors that propagate when measuring the weight-$4$ stabilizers are all correctable for specific orderings of the entangling two-qubit gates Tomita and Svore (2014).

In this paper, we present a non-CSS $[[7,1,3]]$ QEC code that falls into the latter category: every single-qubit Pauli error on the ancillary qubit propagates to the data qubits to form a correctable error. The code was found by a numerical greedy search for stabilizer codes where single-qubit errors on the ancillary qubits do not lead to a logical error Cross (2016). We refer to this code as the Bare $[[7,1,3]]$ code, and we refer to the syndrome measurement method of one ancillary qubit per stabilizer as the bare method.

Given the guarantee that when performing the bare method any single-qubit Pauli error on the ancillary qubits would not lead to a logical error, we want to understand the behavior of the code under higher weight errors. Here we present the results of Monte Carlo stabilizer simulations of the Bare $[[7,1,3]]$ code with $3$ error correcting steps. We used CHP Aaronson and Gottesman (2004) and a Python-based wrapper to obtain logical error rates for the Bare $[[7,1,3]]$ code at the first level of encoding. We report the logical error rates under two different error models. We find that with the bare method, fault-tolerance is not achieved under the standard depolarizing error model because, although the code is resilient to any single-qubit error on the ancillary qubit, certain two-qubit errors whose probability is linearly proportional to the physical error rate are malignant. To protect our code against these errors, we present how to use two additional flag qubits Chao and Reichardt (2017) to achieve fault-tolerant syndrome measurement, which we refer to as the flag method, and report the resulting level-1 pseudothreshold. The bare method is still fault-tolerant under an anisotropic error model applicable to trapped-ion qubits. We report the level-$1$ pseudothreshold of the code under this error model. In the Appendix we present two alternative Monte Carlo error sampling schemes that we employed in the simulations, and we report the level-1 pseudothreshold for two well studied distance-$3$ quantum error correcting codes: the Steane code Steane (1996b); Gutiérrez and Brown (2015); Gutiérrez et al. (2016) and the $5$-qubit code DiVincenzo and Shor (1996); Bennett et al. (1996), for comparison.

The paper is organized as follows. Section II introduces the Bare $[[7,1,3]]$ code, and explains how it handles different errors. Section III describes the two noise models under which we study the performance of the Bare $[[7,1,3]]$ code and demonstrates why the bare method for this error-correcting code is not fault-tolerant under the standard depolarizing noise model. Section IV describes how to use an additional flag qubit to achieve fault-tolerant syndrome measurement for the Bare $[[7,1,3]]$ code. In Section V, we present the simulation scheme and how the simulation results are used to calculate the level-1 pseudothreshold. Section VI presents the results obtained from our simulation for the Bare $[[7,1,3]]$ code under two error models with two different syndrome measurement methods.

II Details of the Bare $[[7,1,3]]$ code

The Bare $[[7,1,3]]$ code was found through a numerical greedy search of stabilizer codes with the property that single-qubit errors on the bare ancillary qubit would not lead to a logical error. Table 1 presents the stabilizer generators and logical $X$ and $Z$ operators of the code. As seen from the stabilizers, the code is non-CSS and degenerate.

FIG 1 shows the configuration of the stabilizers when the Bare $[[7,1,3]]$ code is embeded in a plane.

II.1 Single-qubit errors on a bare ancillary qubit

To illustrate how using bare ancillary qubits can lead to uncorrectable errors in some QEC codes, let us consider the $[[7,1,3]]$ Steane code. From Figure 2, we can see that when measuring the stabilizer $X_{3}X_{4}X_{5}X_{6}$, a single qubit $X$ error on the bare ancillary qubit propagates to form the error $X_{5}X_{6}$ on the data qubits. Although this error is detectable at a later stage, its syndrome is equivalent to an $X_{0}$ error. When this correction is applied, the resulting error $X_{0}X_{5}X_{6}$ is equivalent to the logical operator $X_{L}=X_{0}X_{1}X_{2}X_{3}X_{4}X_{5}X_{6}$ up to a stabilizer.

On the other hand, in the Bare $[[7,1,3]]$ code, all single-qubit errors on the ancillary qubits propagate to become errors with unique syndromes, hence correctable. This is achieved by considering different schedules for coupling the data to the ancillary qubit when measuring the stabilizers. Note that all ancillary qubits are prepared in the $\ket{+}$ state.

The syndromes for the $21$ single-qubit Pauli errors are shown in Table 2. Notice that the syndromes of $Z_{2}Z_{3}$ is $001101$ which is distinct from all syndromes of single-qubit errors. Similarly, $Z_{0}Z_{2}\rightarrow 101000$, $Z_{0}Z_{2}X_{3}\rightarrow 101010$, and $Z_{4}Z_{5}\rightarrow 111010$ all have unique syndromes. Since each gate used in a measurement acts between an ancillary qubit and a data qubit where the ancillary qubit controls a Pauli operator on the data qubit, this observation suggests the following syndrome measurement coupling schedule:

For each weight-$2$ generator, the measurement gates can be coupled to the ancillary qubit in any order. 2. 2.

For the stabilizer $Z_{2}Z_{3}Y_{5}Y_{6}$, couple the measurement gates in left-to-right order. 3. 3.

For the stabilizer $Z_{0}Z_{1}Z_{2}X_{3}Z_{4}Z_{5}$, couple the measurement gates in order of $Z_{0},\,Z_{2},\,X_{3},\,Z_{1},\,Z_{4},\,Z_{5}$.

By using this coupling schedule, for the stabilizer $Z_{2}Z_{3}Y_{5}Y_{6}$, a single-qubit error on the ancillary qubit can propagate the error $Z_{2}Z_{3}$ onto the data qubits, which has a unique syndrome; for the stabilizer $Z_{0}Z_{1}Z_{2}X_{3}Z_{4}Z_{5}$, a single-qubit error on the ancillary qubit can propagate errors $Z_{0}Z_{2}$, $Z_{0}Z_{2}X_{3}$, and $Z_{4}Z_{5}$ onto the data qubits, which all have unique syndromes. Therefore, all single-qubit errors on the ancillary qubits propagate to exclusively correctable errors.

II.2 Two-qubit errors on a bare ancillary qubit

The Bare $[[7,1,3]]$ code is vulnerable to “hook errors”. Figure 3(a) illustrates an instance of a $2$-qubit Pauli error that can occur under the standard symmetric depolarizing error model. This $XX$ error propagates to become $Z_{1}X_{2}X_{3}Z_{4}Z_{5}$, which has syndrome $101011$, the same syndrome as $Y_{1}Z_{4}Z_{5}$. Thus, the correction $Y_{1}Z_{4}Z_{5}$ will be applied, and the resulting error is $X_{1}X_{2}X_{3}$, the logical $X$ operator.

In Fig.3(b) the $2$-qubit $XX$ error on the control-Y gate propagates to become the error $X_{5}Y_{6}$, which has syndrome $000111$, the same as $Y_{3}$. After the correction $Y_{3}$ is applied, the resulting error $Y_{3}X_{5}Y_{6}$ is equivalent to the logical $Z$ operator up to a stabilizer.

III Error Models

III.1 Error Models

To study the properties of the Bare $[[7,1,3]]$ code, we applied two Pauli error models: the standard depolarizing error model and an anisotropic error model.

III.1.1 Standard Depolarizing Error Model

The standard depolarizing error model is a common quantum channel where, after each gate, there is a symmetric depolarization with some probability $p$. After single-qubit gates (including Pauli gates and ancillary qubit preparation gates), a traceless single-qubit Pauli operator, randomly selected from $P=\{X,Y,Z\}$, is applied with probability $p_{s}$. After two-qubit gates, a traceless two-qubit Pauli operator, randomly selected from $Q=\left\{I,X,Y,Z\right\}\otimes\left\{I,X,Y,Z\right\}\setminus\left\{II\right\}$, is applied with probablity $p_{t}$. Although in general $p_{s}\neq p_{t}$, it is common for them to be simulated with the same value Knill (2005). A measurement reports the wrong result with probability $p_{meas}$. For the cases studied here, $p_{meas}$ is set to the single qubit error probability $p_{s}$.

III.1.2 Anisotropic Error Model

For single qubit gates, preparation, and measurement errors remain the same as the standard depolarizing error model. The conceptual motivation for the anisotropic error model is that two-qubit gate errors occur due to errors in the gate coupling. As an example, consider errors in the entangling Mølmer-Sørensen (MS) gate used in trapped ions Sørensen and Mølmer (1999). The MS gate corresponds to $\exp\left(-i(\pi/4)XX\right)$, and an over or under-rortation could result in the coherent error $\exp\left(-i(\epsilon/2)XX\right)$, where $\epsilon$ denotes the over- or under-rotation angle. For $\epsilon$ randomly and symmetrically distributed around [math], this error can be described as a random application of the Pauli error $XX$ with probability $p_{t}$, which is determined by the distribution of $\theta$.

The key idea is that the two-qubit correlation in the error is not any two-qubit error, but only the two-qubit Pauli error aligned with the gate. The error after a Control-$P$ gate is then $ZP$ with probability $p_{t}$. For the specific case of ion traps, this can be derived by including the single qubit rotations necessary to transform the MS gate into a Control-$P$ gate. In this study, we do not include the individual rotations but work at the level of Control-$P$ gates. We expect random errors on the individual qubits in addition to the control error from the two-qubit gate. To account for the random errors, after every two-qubit gate we apply the two-qubit anisotropic error with probability $p_{t}$ followed by single qubit errors with probability $p_{s}$ on the two qubits involved in the gate.

III.2 Fault-tolerance Dependent on Error Model

When performing the bare method under the two error models defined in Section III.1, we can see that all two-qubit errors in the anisotropic error model can be detected and corrected, because a $Z$ error on the control qubit does not propagate to form other errors on the data. However, for certain two-qubit errors in the standard depolarizing error model, such as the $XX$ error as seen in Fig. 3(a) and Fig. 3(b), the errors propagate to form uncorrectable hook errors. Therefore, the Bare $[[7,1,3]]$ code with the bare method can achieve fault-tolerance under the anisotropic error model because all errors that occur with probability linear in the error rate of physical operations are correctable; however, the same syndrome measurement method cannot achieve fault-tolerance under the standard depolarizing error model since certain two-qubit errors that occur with probability linear in the physical error rate propagate to become uncorrectable logical errors.

IV Fault-tolerance With a Flag Qubit

Since the bare method is not fault-tolerant for the Bare $[[7,1,3]]$ code under the standard depolarizing error model, additional resources would be required to ensure fault-tolerance. In this section we propose the method of using two additional flag qubits to perform fault-tolerant syndrome measurement on the Bare $[[7,1,3]]$ code. The idea of the flag method was used by Yoder and Kim Yoder and Kim (2017), and presented in detail by Chao and Reichardt Chao and Reichardt (2017).

Since the source of logical errors for the Bare $[[7,1,3]]$ code are the hook errors propagated from errors on the ancillary qubit, we can use flag qubits to detect errors on the ancillary qubit that can propagate to form these hooks. In order to use the flag method, we need to change the order of the gates to measure the stabilizer $Z_{0}Z_{1}Z_{2}X_{3}Z_{4}Z_{5}$ to: $Z_{0},X_{3},Z_{4},Z_{2},Z_{1},Z_{5}$. The purpose of this order change is to ensure that all errors that could trigger the flag qubit measurement have distinct syndromes. As we can see in TABLE 4, this change of order makes the Bare [[7,1,3]] code vulnerable to certain single-qubit errors that were correctable with the old order. But since these errors all trigger the flag qubit measurement and all result in distinct syndromes, they are still correctable.

The circuits to fault-tolerantly measure the high-weight stabilizers are shown in Figure 4. The second ancillary qubit initialized in the $\ket{0}$ state in both circuits is the flag qubit. With no errors present, these circuits behave exactly the same as the circuits using bare ancillary qubits for syndrome measurement, and the $Z$-basis measurements on the flag qubits will always give $\ket{0}$. In Figure 4(a) errors after gate $a$ and $d$ cannot create uncorrectable hook errors, and in Figure 4(b) errors after gate $a$ and $f$ cannot create uncorrectable hook errors. Errors after all other gates in these two circuits will be detected by causing a $\ket{1}$ measurement outcome for the flag qubit. These errors and their syndromes are listed in Table 3 and Table 4. Each of these errors has a distinct syndrome, so it can be corrected. Note that $Y$ errors on the ancilla qubit have the same effect on the data as $X$ errors.

As argued by Chao and Reichardt Chao and Reichardt (2017), this method of syndrome measurement is fault-tolerant. Under the standard depolarizing model, all errors that appear with probability linear in the physical error rate can be detected and corrected using the above flag method, hence making the Bare $[[7,1,3]]$ code fault-tolerant under the standard depolarizing error model.

V Simulation scheme

In this section we present the circuit used in the simulation, the QEC scheme used to perform correction after each round of the Bare $[[7,1,3]]$ code with noise, and the calculations we performed to obtain logical error rates. The simulations were done using the CHP stabilizer simulator Aaronson and Gottesman (2004). The simulation follows the 1-rectangle (1-Rec) formalism Aleferis et al. (2006) for distance-3 and level-1 encoding, where the 1-Ga we are simulating is the level-1 logical identity gate.

V.1 Simulation Circuit

Fig. 5 shows the quantum circuit we constructed to simulate one error-correcting step of the bare method for the Bare $[[7,1,3]]$ code. The simulated gate is a logical identity followed by an error-correction gadget. The gates are grouped together for each ancillary qubit measurement, and the order of qubit-coupling between the data qubits and ancillary qubits follows exactly the scheduling as required for fault-tolerant measurements of each stabilizer generators. For each gate shown in this circuit, errors of appropriate type are inserted after it with a probability given by the noise model. The circuit for simulating the flag method requires two additional flag qubits, and has a different order of qubit-coupling between the data and ancillary qubits, as described in Section IV.

The syndrome measurement is repeated up to three times with freshly prepared ancillary qubits. The repetition is necessary due to errors during or between syndrome measurements MacWilliams and Sloane (1977). If the first two error syndromes agree, correction is performed based on the error syndrome. If the two syndromes disagree, a third syndrome is measured and correction is performed based on the third syndrome.

V.2 Logical Error Rate Calculation

We calculate the logical error rate under the two different error models for various physical error strengths. For each run of in the Monte Carlo simulation, we initialize all the data qubits in state $\ket{0}$, 6 of the ancillary qubits in state $\ket{+}$ for syndrome measurements, and 2 of the ancillary qubits in state $\ket{0}$ to be used as flag qubits for the high-weight stabilizers. We then perform one round of noise-free stabilizer measurements to project the state of the data qubits to the logical $\ket{0}$ state. Then the simulation proceeds as follows:

Perform 2 or 3 rounds of error correction with random errors inserted using the importance sampling scheme. 2. 2.

Apply the decoder to determine the corresponding error configuration and correct accordingly. 3. 3.

Perform noise-free correction to the final state to project the state back to the codespace. 4. 4.

If the final state is different from the initial one, count as one logical error.

In the importance sampling scheme (see Appendix A.2), we classify the error configurations into subsets according to the number of single- and two-qubit errors present in the configuration. The subset consisting of configurations of $s$ single-qubit errors and $t$ two-qubit errors is labelled by $(s,t)$. For example, if during the execution of the QEC circuit, two single-qubit preparations were faulty and an error occurred after one of the CNOTs, this error configuration belongs to the subset $(2,1)$.

We perform Monte Carlo simulations on selected error subsets and compute the logical error rate per subset, $p_{L}(s,t)$, by calculating the ratio of the successful runs over the total number of runs. The total logical error rate, $p_{L}$, is calculated as a weighted average over the selected error subsets:

[TABLE]

where $A_{s,t}$ is the probability of occurrence of subset $(s,t)$, that is, the total probability of occurrence of all error configurations with $s$ single-qubit errors and $t$ two-qubit errors.

We use the calculated logical error rates at different physical error strengths to estimate the pseudothreshold of the code under a particular error model Svore et al. (2006). The pseudothreshold is the intersection between the physical error rate line $y=2p/3$ and the logical error rate $p_{L}(p_{s},p_{t})$. The reason for using this line instead of $y=p$ is that, if we assume a symmetric depolarizing noise model on a single qubit, the infidelity is given by $2p/3$. More intuitively, if we focus on a single-qubit Pauli state, like $|0\rangle$, only two Pauli errors ($X$ and $Y$ in this case) will cause an error. Furthermore, this will result in a slightly more pessimistic value for the pseudothreshold.

VI Results

In this section we present and analyze the results from numerical Monte Carlo simulations of the Bare $[[7,1,3]]$ code under different noise models using the two different syndrome measurement methods. We first focus on the standard depolarizing error model and then on the anisotropic error model. We show that using the bare method, the Bare $[[7,1,3]]$ code does not have a pseudothreshold under the standard depolarizing error model, due to some uncorrectable two-qubit errors that have probability linear in the physical error strength.

VI.1 Standard Depolarizing Error Model

Fig. 6 presents the logical error rates for the standard depolarizing model with $p_{s}=p_{t}=p$ for several values of $p$. For the bare method, the best fit corresponds to a function with linear term as leading term, while for the flag method the best fit corresponds to a function with quadratic term as leading term.

For the bare method, although there is an intersection between the logical error rate and the physical error rate, the curves still remain parallel for physical error rates below the intersection. The fact that there is still a linear term in the logical error rate implies that we would not observe an exponential suppression on the logical error rate with subsequent levels of concatenation. Thus, this intersection is not a pseudothreshold for the Bare $[[7,1,3]]$ code, and the code is not fault-tolerant under the standard depolarizing error model. Examples of why this would happen are shown in Fig. 3.

For the flag method, all errors that occur with probability linearly proportional to the physical error rate can be corrected. By performing a quadratic fit for the logical error rates and computing the intersection of the fitting curve with the error rate of an unencoded qubit, we obtain a level-1 pseudothreshold of $1.08\times 10^{-3}$.

VI.2 Anisotropic Error Model

We now calculate the pseudothreshold of the Bare $[[7,1,3]]$ code under the anisotropic error model. In this model, the physical error strength after each gate is $p$, and $p_{s}=p_{t}=p$.

By performing a quadratic fit for the logical error rates and computing the intersection of the fitting curve with the error rates of an unencoded qubit, we obtain level-1 pseudothreshold for the Bare $[[7,1,3]]$ code with both syndrome measurement methods. This is because all single-qubit and two-qubit errors that occur with probability linear in $p$ are guaranteed to be detected and corrected by the Bare $[[7,1,3]]$ code. From Fig. 7 we can see that for the bare method, the level-1 pseudothreshold is at $2.0\times 10^{-4}$. For the flag method, the level-1 pseudothreshold is at $4.0\times 10^{-4}$.

The main reason for the difference between the two pseudothresholds is that the number of uncorrectable error configurations with probability quadratically proportional to the physical error rate is higher for the bare method. Consider, for example, that some errors with probability quadratically proportional to the physical error rate can behave the same as the two-qubit errors listed in Table 3 and Table 4. Those errors could lead to logical errors with the bare method, but can be corrected with the flag method.

VI.3 Comparison of Results across Error Models

From the results presented in Fig. 6 and Fig. 7 we can see that the level-1 pseudothreshold under the anisotropic error model is lower than that under the standard depolarizing error model. This is because in the anisotropic error model, after each two-qubit gate we are simulating a single-qubit random Pauli error on each qubit with probability $p_{s}$ (Section III.1), leading to more possible error locations in the overall circuit. If we assume the single-qubit errors and two-qubit errors are equally probable, as we did in the results shown in Fig. 6 and Fig. 7, errors after the two-qubit gates are 3 times more likely to occur under the anisotropic error model than under the standard depolarizing model, because of the extra single-qubit Pauli errors. Hence, the Bare $[[7,1,3]]$ code under the anisotropic error model has a lower pseudothreshold than under the standard depolarizing model.

VII Conclusions

In this paper we have presented properties of a new $[[7,1,3]]$ stabilizer code that can achieve fault-tolerant syndrome measurements using a single ancillary qubit under the anisotropic error model, and showed why certain two-qubit errors under the standard depolarizing error model would prevent this code from achieving fault-tolerant measurements. In particular, the limit on total number of syndrome outcomes makes it impossible for the lookup table decoder to detect and correct all two-qubit errors in the standard depolarizing error model. Additionally, we showed that using the flag method the Bare $[[7,1,3]]$ code can achieve fault-tolerance under both the standard depolarizing model and the anisotropic model. Overall, with the flag method the Bare $[[7,1,3]]$ code shows better performance under realistic error models.

We note that the $[[7,1,3]]$ triangle code presented by Yoder and Kim Yoder and Kim (2017) also does not require additional ancillary qubit preparations and is able to achieve fault-tolerance under the standard depolarizing error model. However, their code would not be identified by the search criteria that identified our code Cross (2016): a syndrome measurement with strictly bare ancillary qubits on their code would not be able to correct all hook errors originated from a single qubit error on the ancillary qubit. Instead they proposed an interwoven syndrome measurement method to achieve fault-tolerance. Since the interwoven method is not applicable for the Bare $[[7,1,3]]$ code, no direct comparison between the two codes can be easily made. But if the flag method Chao and Reichardt (2017) was to be applied on both codes, they can both achieve fault-tolerance under the standard depolarizing error model with the same amount of resources, and the pseudothreshold we obtained for the Bare $[[7,1,3]]$ code for the 1-Rec is comparable to the pseudothreshold reported by Yoder and Kim for the exREC Aleferis et al. (2006).

A natural direction of future work would be to study the behavior of the Bare $[[7,1,3]]$ code under realistic other error models such as coherent errors and amplitude damping Gutiérrez et al. (2013), and tailor this code for architecture-specific noise environments where limitations on ancillary qubit resources and measurement times are required.

The fact that the Bare $[[7,1,3]]$ code with the bare method does not perform well under the theoretical standard error model but can achieve fault-tolerant measurements under a more realistic error model suggests that more effort should be put into designing and finding error correcting codes that help achieve fault-tolerant quantum computation under realistic scenarios Robertson et al. (2017). As realistic error models are becoming more and more relevant, development of environment-specific error correcting codes will become more important.

Acknowledgements.

This work would not have been possible without the help of Andrew Cross. We would like to thank him for discovering this code, for encouraging us to study its properties, and for discussions and comments on the manuscript. We thank Colin Trout and Theodore Yoder for comments on the manuscript and discussions on the flag method. This work was supported by the Office of the Director of National Intelligence - Intelligence Advanced Research Projects Activity through ARO contract W911NF-10-1-0231 and the National Science Foundation grant PHY-1415461.

Appendix A Efficient Sampling Algorithm for Monte Carlo Simulations

For a given QEC circuit and a physical noise model, obtaining an exact algebraic expression for the logical error rate is in principle possible. In the context of a stabilizer code and a noise model consisting of stochastic discrete errors, this amounts to ($1$) enumerating every possible error configuration on the circuit, ($2$) calculating its probability of occurrence, and ($3$) determining whether or nor it results in a logical error. The logical error rate is then given by:

[TABLE]

where $N_{c}$ is the total number of error configurations, $A_{i}$ is the probability of occurrence of error configuration $i$, and $p_{i}=0(1)$ if the error configuration $i$ is correctable (uncorrectable). Although possible in principle, the exact computation of a logical error rate is infeasible in practice, due to the high cardinality of the error configuration set. For a circuit with $n_{g}$ gates and $s$ possible different errors after each gate, $N_{c}=(s+1)^{n_{g}}$. Even a modest circuit, like a level-1 QEC routine for a distance-$3$ code consisting of $3$ rounds of stabilizer measurements, contains more than $100$ gates, making the exact computation of the logical error rate impractical.

It is, therefore, common to employ Monte Carlo methods to estimate $p_{L}$ Knill (2005); Raussendorf and Harrington (2007); Fowler et al. (2009); Janardan et al. (2016). The basic procedure to obtain a logical error rate consists of two steps: ($1$) the generation of a faulty circuit (an error configuration) based on the physical noise model and ($2$) the simulation of the circuit to determine if that particular error configuration is correctable. In this section, we describe the two different Monte Carlo methods used in the first step. The first one utilizes traditional direct sampling of the whole error configuration set. The second one relies on importance sampling of the error configuration subsets that are relevant to the logical error rate. Both methods are based on direct sampling, i.e., each error configuration is completely uncorrelated from the previous ones.

A.1 Traditional Sampler

To generate an error configuration, the traditional sampler traverses the circuit exhaustively and after each gate an error is inserted with a probability given by the noise model. This approach is convenient for high error rates. However, it is problematic if the error rate is low, because most of the times no error is inserted. For illustrative purposes, consider a simple case where the error rate $p=0.1\%$ is the same for ech gate and the circuit has $N_{g}=100$ gates. The traditional sampler will return an error-free circuit $(1-p)^{n_{g}}\approx 90\%$ of the runs. Furthermore, if the circuit corresponds to a fault-tolerant QEC protocol of a distance-$3$ code, by construction no error configuration of weight-$1$ will result in a logical error. This implies that $(1-p)^{n_{g}}+n_{g}p(1-p)^{n_{g}-1}\approx 99.5\%$ of the runs will generate an error configuration which is known a priori to be correctable. The limitation of the traditional sampler becomes even more dramatic for lower error rates and codes of higher distance Bravyi and Vargo (2013).

A.2 Importance Sampler

It is possible to split the error configuration set into subsets based on each configuration’s error weight (number of errors). The key advantage of the importance sampler relies on two features of this particular subset splitting: ($1$) it is straightforward to compute analytically the total probability of occurrence of each subset (the sum of the probabilities of occurrence of the error configurations in the subset) and ($2$) for low error rates we can safely ignore high weight error subsets, since their probability of occurrence will be vanishingly small.

Here we consider subsets in terms of both errors that occur after single-qubit gates and two-qubit gates. For example, a subset labelled by $(s,t)$ contains all error configurations of the circuit with $s$ errors after single-qubit gates and $t$ errors after two-qubit gates. Notice that an error after a two-qubit gate can still be of weight $1$. Let $n_{s}$ and $n_{t}$ be the total number of single-qubit gates and two-qubit gates in this circuit. We assume an error model where the error probability is the same for all single-qubit gates ($p_{s}$) and the error probability is also the same for all two-qubit gates ($p_{t}$). The probability of occurrence of the error subset $(s,t)$ is then:

[TABLE]

Given a quantum circuit and a noise model, the algorithm to estimate the logical error rate using the importance sampler consists of three steps:

Select a tolerance value. This corresponds to the total added probability of occurrence of the high weight subsets that will not be sampled. In the worst scenario imaginable, every error configuration in the excluded subsets would result in a logical error. The tolerance value represents the worst-case discrepancy between the real and the obtained logical error rate. In particular, it provides a worst-case upper bound to the logical error rate. 2. 2.

For each error subset $(s,t)$, use direct Monte Carlo sampling to approximate its logical error rate $p_{L}(s,t)$. The sampling is done by randomly selecting $s$ single-qubit gates and $t$ two-qubit gates and adding errors after them. 3. 3.

Calculate the total logical error rate for the circuit:

[TABLE]

where $A_{s,t}(p_{s},p_{t})$ is computed analytically using Equation 2.

Notice that the logical error rate $p_{L}(s,t)$ for a particular $(s,t)$ subset is not a function of the physical error rates $p_{s}$ and $p_{t}$. This means that, for a given circuit and noise model, we can pre-compute the logical error rate for each relevant subset, and use those values to evaluate the total logical error rate for different physical error rates. In contrast to the traditional sampler, there is no need to re-run the Monte Carlo simulations for different values of $p_{s}$ and $p_{t}$. We simply calculate new values for the probabilities of subset occurrence $A_{s,t}$ and compute $p_{L}$ using Equation 3. Once the Monte Carlo simulations for each relevant subset are done, the logical error rates for different physical error rates can be computed at no additional cost, making the importance sampler much more efficient than the traditional one. However, for high physical error rates (about $10^{-2}$ and higher) the importance sampler becomes either inaccurate or very slow. The trade-off arises because as the error rate increases so does the probability of occurrence of higher weight subsets and therefore the number of subsets that need to be included to obtain an accurate result. In this error regime, it is suitable to employ the traditional sampler.

A.3 Comparing Performance of Sampling Algorithms

In order to test the performance of the importance sampler, we simulated the logical error rate for the Steane $[[7,1,3]]$ code, the five-qubit code, and the Bare $[[7,1,3]]$ code with both the traditional and the importance sampling algorithm. To make sure that the results of the two sampling algorithms are comparable, we analytically proved that the probability for an arbitrary error to occur at any location in the circuit is the same for both sampling algorithms.

From both Fig. 8 and Fig. 9 we can see that the results of the two sampling algorithms coincide exactly at lower physical error rates, but can start to diverge as physical error rate increases, with the logical error rate obtained from the traditional sampler slightly higher than that from the importance sampler. This is because for a given number of subsets, at lower physical error rates these subsets are enough to calculate the cumulative logical error rate to a high accuracy, but for higher physical error rates the importance sampler must sample a larger number of error subsets in order to achieve the same level of accuracy in the cumulative logical error rate. In this case, the traditional sampler accounts for all error subsets of this circuit, while the importance sampler only accounts for a small number of subsets, resulting in a smaller logical error rate.