2-Designs and Redundant Syndrome Extraction for Quantum Error Correction

TL;DR

This paper introduces a method using 2-designs to optimize redundant syndrome extraction in quantum error correction, improving fault tolerance especially when measurement errors are significant.

Contribution

It applies the mathematical theory of 2-designs to design measurement protocols that enhance syndrome separation, improving quantum error correction performance.

Findings

Design-based redundancy improves error correction cost and performance.

Simulation results for various quantum codes demonstrate effectiveness.

Method is particularly beneficial when measurement errors are prevalent.

Abstract

Imperfect measurement can degrade a quantum error correction scheme. A solution that restores fault tolerance is to add redundancy to the process of syndrome extraction. In this work, we show how to optimize this process for an arbitrary ratio of data qubit error probability to measurement error probability. The key is to design the measurements so that syndromes that correspond to different errors are separated by the maximum distance in the signal space, in close analogy to classical error correction codes. We find that the mathematical theory of 2-designs, appropriately modified, is the right tool for this. Analytical and simulation results for the bit-flip code, the 5-qubit code, and the Steane code are presented. The results show that design-based redundancy protocols show improvement in both cost and performance relative to conventional fault-tolerant error-correction schemes in situations, quite important in practice, where measure errors are common. In the near term, the construction of a fault-tolerant logical qubit with a small number of noisy physical qubits will benefit from targeted redundancy in syndrome extraction.

Tables

Table 1. Table 1: Failure rate and cost for 3 error-correction protocols for the 3-qubit bit-flip code.

Protocol	Failure Rate	Cost
Minimal QEC	$2p_m-p_m^2+3p_q^2$	$2$
Fault-tolerant QEC	$6p_m^2+3p_q^2$	$4+2p_m$
DBR	$3p_m^2+3p_q^2+9p_m{p}_q$	3

Table 2. Table 2: Failure rate and cost for 4 error-correction protocols for the Steane [[7,1,3]] and [[7,1,3,1]] codes.

Protocol	Failure Rate	Cost
Minimal QEC	$3p_m-3p_m^2+21p_q^2$	$3$
Fault-tolerant QEC	$9p_m^2+21p_q^2$	$6+3p_m$
MR with $S_7$	$6p_m^2+21p_q^2+28p_m{p}_q$	$4$
DBR	$21p_q^2$	7

Full text

I Introduction

A working quantum computer must be fault-tolerant: the reliability of all components must be considered, and appropriate measures taken for compensation of malfunctions Shor1996 ; Preskill1999 . Error correction forms the core of this process. Error syndromes are extracted and used to generate the information needed to set the computer back on the right path. The syndrome information may itself contain errors because of imperfect measurements. This aspect of fault tolerance was recognized at an early stage of the development of the theory. In the two most prominent syndrome extraction protocols, the remedy was to repeat measurements already made Steane1996 ; Divincenzo1996 , thereby building in redundancy. This is a straightforward way to make the syndrome information more reliable.

In the last few years, more sophisticated schemes have been proposed. Fujiwara et al. noted that measuring more than a minimal set of stabilizers could be a more efficient way to extract reliable information and noted a possible connection to designs Fujiwara2014 ; Fujiwara2015 . Ashikmin et al. generalized existence theorems and the quantum Singleton bound of standard quantum error correction (QEC) theory so that they take into account redundancy in measurements Ashikhmin2014 . Crow et al. used redundancy in syndrome extraction to give thresholds for qubit performance in a coherent error-correction scheme Crow2016 .

In this letter, we show how to optimize measurement redundancy by applying the theory of 2-designs, 111 2-designs are also known as balanced incomplete block designs. Our sense of the word 2-design is not related to quantum 2-designs, which are probability distributions over quantum states., This is called design-based redundancy (DBR). 2-designs have long been used in classical error correction pless . We investigate both a minimal redundant extraction scheme (MR) as well as the more comprehensive DBR.

It is sufficient to use a simple model for the faults. The key feature of this model is to separately define the qubit error probability $p_{q}$ and the syndrome measurement error probability $p_{m}$. Different physical implementations of quantum computation will have very different values of the ratio $p_{q}/p_{m}$ and this will strongly influence the optimal DBR protocol. In this work we will only consider the simple situation of a quantum memory that is periodically refreshed by error correction; more complicated scenarios with active gates would complicate the analysis but not introduce significant new concepts. The discussion is restricted to stabilizer codes Gottesman1996 . It may be possible to use 2-designs to improve other codes, but it appears to be more complicated. We stress that DBR is equally applicable to measurement-based error correction and coherent error correction. For definiteness, we will use the language of measurement-based QEC in this work.

II Bit Flip Code

This section is included in order to introduce the basic ideas of DBR. It treats the elementary example of the 3-qubit bit flip code NielsenChuang . The three physical qubits store a single bit of quantum information and there is a probability $p_{q}$ of a bit flipping. No other qubit errors are allowed. Stabilizers $S_{1}=Z_{1}Z_{2}$, $S_{2}=Z_{2}Z_{3}$ and $S_{3}=Z_{3}Z_{1}$ can each be measured, always yielding $\pm 1$. An incorrect measurement result is obtained with probability $p_{m}$. The starting state (chosen arbitrarily in the code subspace) is $|000\rangle$; after a certain time 1 or more bits may flip and we measure a set of stabilizers, perhaps repeatedly. We define an event $e$ to be the final state of the qubits together with the measurement results. Each event $e$ has a probability $P(e)$ with $0\leq P(e)\leq 1$ and a success factor $s(e)=0$ or $s(e)=1$ when the event is respectively uncorrectable or correctable. For example, if the textbook procedure of measuring only the generators of the stabilizer group $S_{1}$ and $S_{2}$ is used, a possible event is $e_{0}=\{|001\rangle,+1,-1\}$. This can be made fault-tolerant by repeating the measurements and using majority rules on the measurement results. Assuming independence, the probability of this event is $P(e_{0})=p_{q}(1-p_{m})^{2}(1-p_{q})^{2}$ since there is 1 qubit error and 0 measurement errors. $s(e_{0})=1$ since the information obtained from the measurements allows us to correct the error. The total failure probability of an error correction protocol, including possible DBR, is $F=1-\Sigma_{e}P(e)s(e)$. In addition, we define the cost C of a protocol to be the expected total number of stabilizer measurements in a correction cycle.

The DBR protocol differs from both the simple protocol and its fault-tolerant extension in that one measures * the complete set of stabilizer group generators* $S_{1}$, $S_{2}$ and $S_{3}$. This already builds in redundancy; if there is one measurement error then exactly one of the $S_{i}$ is equal to $-1$. If 2 of the $S_{i}$ is equal $-1$ then there is a unique instruction as to which bit to flip back. (Here and henceforth we use $S_{i}$ both for the operators and for the result of measuring the operators.) The key point is that there is a unique signal even if there is a measurement error. For this toy code, MR and DBR are identical; for large codes this is not the case.

Once protocols are established, then it is straightforward to sum over the events and compute the failure rates and costs. In Table 1 we tabulate the results to quadratic order in $p_{q}$ and $p_{m}$ and the cost to linear order.

The fact that minimal QEC has a linear term in $p_{m}$ is the signature that it is not fault-tolerant and is therefore not a candidate for a working computer. More importantly, the fault-tolerant version of conventional QEC is always more costly than DBR and the failure rate for conventional QEC exceeds that of DBR whenever $6p_{m}^{2}+3p_{q}^{2}>3p_{m}^{2}+3p_{q}^{2}+9p_{m}p_{q}$. This reduces to $p_{m}>p_{q}/3$, which is likely to happen in many implementations. It is interesting that DBR is superior even for $p_{m}=p_{q}$, a case often considered.

III 2-designs

The crucial feature of DBR for the bit flip code is that the syndrome possesses a unique signature when there is a measurement error. This feature can be generalized to more complex codes that can correct phase flip as well as bit flip errors. Consider an $[[n,k,d]]$ stabilizer code with $n$ the number of physical qubits, $k$ the number of logical qubits and $d$ the distance; the code can correct errors on up to $(d-1)/2$ physical qubits. We will focus on $k=1$ and the logical operators are $X_{L}=\otimes_{i=1}^{n}X_{i}$ and $Z_{L}=\otimes_{i=1}^{n}Z_{i}$, as in the Steane $[[7,1,3]]$ code. Our notation in this paper extends the usual one slightly, since we wish also to detect up to $s$ syndrome measurement errors - hence we refer to $[[n,k,d,s]]$ codes. Standard quantum error correction without repetitions has $s=0$.

In DBR for a CSS (CSS-DBR) code we measure $m=C/2$ stabilizer operators of the form $S=X_{i_{1}}X_{i_{2}}\cdots X_{i_{w}}$ and $m=C/2$ stabilizer operators of the form $S=Z_{i_{1}}Z_{i_{2}}\cdots Z_{i_{w}}$. Each stabilizer has weight $w$. Here $\{i_{1},i_{2},...,i_{w}\}$ are chosen from the set $\{1,2,\dots,n\}$, and any given $S$ is completely defined by this choice. Thus for CSS codes X and Z errors are handled separately, so we simply use 2 copies of a single design, and this gives a particularly economical and effective DBR protocol. The measurement result of the $Z$-type stabilizers is different for any bit flip error. Tabulating these possible syndrome results yields an $m\times(n+1)$ matrix $E$ whose entries are $\pm 1$. The entry $E_{ij}$ is the result of correctly extracting the value of $S_{i}$ for a bit flip on the $j$-th physical qubit. At a minimum, the rows of $E$ must all be distinct in order to diagnose an error uniquely. We wish to go beyond this. Fault tolerance in DBR is achieved not by repetition but by choosing our measurements so that the results differ by as much as possible. This motivates the use of 2-designs for our choice of measurements.

A 2-design is a family of subsets of a larger set. This family must fulfill certain conditions. For present purposes there is a set of $n$ qubits and the indices on each $Z$-type stabilizer to be measured defines a subset of the qubit indices. Thus the family of subsets is determined by the choice of $Z$-type stabilizers. There are $m$ subsets. The conditions for this choice to be a 2-design are: (1) each subset has the same size $w$; (2) every index must appear in exactly $\rho$ subsets; (3) every pair of indices appears in exactly $\lambda$ subsets. The parameters are not all independent. They satisfy the basic 2-design relations $mw=n\rho$ and $\lambda(n-1)=\rho(w-1)$. These equations are proved using counting arguments.

Let us define the Hamming-like distance $D$ between any two $Z$-type stabilizers $S_{i}$ and $S_{i^{\prime}}$ as $D(S_{i},S_{i^{\prime}})=\Sigma_{j=1}^{r}|E_{ij}-E_{i^{\prime}j}|$, where $E_{ij}$ is the result when the $j$th qubit has flipped. Then if the choice of the $S_{i}$ is a 2-design we have that $D(S,S^{\prime})=2(\rho-\lambda)$ for all $S$ and $S^{\prime}$. This may be shown by arguments similar to those in pless . This the key feature of 2-designs for error correction purposes: it enables us to systematically maximize $\rho-\lambda$.

To illustrate the definition we give the example of a simple 2-design known as the order-2 biplane. It applies to a system of $n=7$ qubits. The stabilizers are $S_{1}=Z_{1}Z_{5}Z_{6}Z_{7}$, $S_{2}=Z_{2}Z_{4}Z_{6}Z_{7}$, $S_{3}=Z_{3}Z_{4}Z_{5}Z_{7}$, $S_{4}=Z_{1}Z_{2}Z_{4}Z_{5}$, $S_{5}=Z_{1}Z_{3}Z_{4}Z_{6}$, $S_{6}=Z_{2}Z_{3}Z_{5}Z_{6}$, $S_{7}=Z_{1}Z_{2}Z_{3}Z_{7}$. It is not hard to verify that this choice satisfies the constraints for a 2-design with $w=4$, $m=7$, $\rho=4$ and $\lambda=2$. We will use this 2-design below.

The fundamental criterion for the choice of stabilizers is the minimization of the failure rate $F$ and the cost $C$. We have seen that the natural arena for this is the 2-design. However, not all 2-designs can be used in conjunction with stabilizer quantum error correction. There is one constraint for all DBR schemes based on 2-designs.

Constraint 1. The definition of a stabilizer requires that it must commute with the logical operators, i.e., $[S,\otimes_{i=1}^{n}X_{i}]=[S,\otimes_{i=1}^{n}Z_{i}]=0$ for all $S$. A short calculation shows that this is true if and only if $w$ is even. (See supplementary material.)

Constraint 2. (CSS-DBR only.) The use of two copies of a design generates an additional constraint. The stabilizer group is commutative. All $X$-type stabilizers trivially commute with each other; the same is true for the $Z$-type stabilizers. An $X$-type stabilizer commutes with a $Z$-type stabilizer if and only if the intersection of the set of indices of the $X$-type stabilizer with the set of indices of the $Z$-type stabilizer has even cardinality. This happens for all such pairs of stabilizers if and only if $\lambda$ is even.

These two constraints rule out a majority of 2-designs for CSS-DBR. The order-2 biplane with $w=4$ and $\lambda=2$ is allowed, but the natural successor is the order-3 biplane with $w=5$: it cannot serve as the basis for an DBR scheme.

IV Results

IV.1 5-qubit code

The [[5,1,3]] perfect code is not a CSS code, so a single 2-design is used for all errors. We take the stabilizer group generated by $S_{1}=X_{1}Z_{2}Z_{3}X_{4},S_{2}=X_{2}Z_{3}Z_{4}X_{5},S_{3}=X_{1}X_{3}Z_{4}Z_{5},$ and $S_{4}=Z_{1}X_{2}X_{4}Z_{5}$, which is then a [[5,1,3,1]] code. The full stabilizer group is an instance of the class of designs generated from Hadamard matrices, appropriately called Hadamard designs. In particular, the design here is the complement to the $n=3$ Hadamard design Dinitz1992 . Once the stabilizer set is chosen we can compute the failure rate $F_{DBR}$ as a function of $p_{m}$ and $p_{q}$. DBR stands for "design-based redundancy". We also compute the failure rate $F_{MR}$ for a scheme in which minimal redundancy (MR) is employed: only one additional stabilizer is measured, namely $S_{1}S_{2}S_{3}S_{4}$. This operator is the product of the minimal set of generators. With this choice the resulting protocol is somewhat analogous to a single parity check in classical error correction. Finally we compute the failure rate $F_{QEC}$ for fault-tolerant QEC. Analytical results for all three rates are given in the supplementary material. Choosing $F_{QEC}$ as a basline, we plot the relative failure rates in Fig. 1 for a range of error probabilities relevant to near-term quantum information processing. Note that MR has an advantage over QEC for $p_{m}>XXXp_{q}$. Both are fault-tolerant with respect to $p_{m}$ in that $F_{QEC}.F_{MR}\sim p_{m}^{2}$. However, DBR is superior to both QEC and MR for all $p_{m},p_{q}$ in the appropriate regime. This can be traced back to the fact that $F_{DBR}\sim p_{m}^{4}$. Note that MR is cheaper than DBR in terms of number of measurements, so it may be preferable in intermediate regimes of $p_{m}$.

IV.2 Steane code

In our notation, the Steane code with the minimal set of measurements is a $[[7,1,3,0]]$ code. When syndrome measurements errors occur, it is not fault-tolerant. 3-fold repetition of its measurement sequence with majority rules gives a $[[7,1,3,1]]$ code. The order-2 biplane DBR procedure utilizes 14 stabilizers: those given in the previous section and another 7 with $Z_{i}\rightarrow X_{i}$. It is a fault tolerant $[[7,1,3,1]]$ code.

We again give the comparison of failure rates for 3 protocols: the repeated Steane code, denoted QEC; an MR code with two additional stabilizers, one of the X type and one of the Z type, in both cases a product of the usual generators; and the MR approach measuring the full stabilizer group. This final set of stabilizers corresponds to 2 copies of the order-2 biplane. The results demonstrate that DBR has a distinct advantage over the other 2 protocols. It is even more dramatic than in the 5-qubit case. This combination of DBR with a CSS code is particularly effective in repairing measurement errors. Again, the MR approach may also be useful in practical cases - everything depends on the cost and reliability of measurements in a specific implementation.

V Conclusion

In this paper we have focused on 2-designs that appear naturally in straightforward modifications of well-known codes. But a longer-term goal would be to use known 2-designs to improve syndrome extraction, thus improving quantum error-correction in cases where errors in the measurement process are important. This not straightforward, since there is no general classification theorem for 2-designs, though a large number of special cases and some infinite families are known Rudolf1985 . This is a promising line of research.

Once a quantum processor is characterized and $p_{q},p_{m}$ are known, we can look at the failure rates to determine which approach to take. The next consideration is cost. In a Shor-style extraction protocol each stabilizer measurement requires a number of ancilla qubits one greater than the weight of the operator itself Shor1996 . In fault-tolerant QEC ancilla qubits can be reused on subsequent cycles of syndrome extraction. Thus, even though the number of QEC measurements may exceed that of DBR for a given code, the size of the quantum register required may in fact be larger for DBR. Recent ideas for using fewer ancilla qubits could be used to bring down the potential cost disparity between QEC and DBR Chao2018 . This comes at the price of adding more gates, so an appraisal of which is the most fruitful approach involves a balancing act between number of qubits and circuit depth.

In the near term, we may expect the development of machines with 50-100 fairly noisy qubits and gates (the "NISQ" era). One important goal for this era is the development of a single fault-tolerant error-corrected logical qubit. The correction process involves multiple gates while the data qubits will often have reasonably long coherence times. In this situation, probably the most common one, we expect $p_{m}>p_{q}$. This means that the strategies outlined in this paper will be very relevant for this important goal.

Acknowledgements.

This research was sponsored in part by the Army Research Office (ARO) under Grant Numbers W911NF-17-1-0274.The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office (ARO), or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.

Author Contributions

H.S. performed the numerical simulations and V.N.P and R.J. worked on analytic calculations, analyzed the results and prepared the manuscript. D.C. provided insight on the structure of stabilizer codes as viewed through the lens of 2-designs and E.B. supported the work with a significant body of knowledge relating to classical coding. The entire work was carried out under the supervision of R.J.

Competing Interests

The authors declare no competing interests.