## Abstract

Recently, quantum error-correcting codes have been proposed that capitalize on the fact that many physical error models lead to a significant asymmetry between the probabilities for bit- and phase-flip errors. An example for a channel that exhibits such asymmetry is the combined amplitude damping and dephasing channel, where the probabilities of bit and phase flips can be related to relaxation and dephasing time, respectively. We study asymmetric quantum codes that are obtained from the Calderbank–Shor–Steane (CSS) construction. For such codes, we derive upper bounds on the code parameters using linear programming. A central result of this paper is the explicit construction of some new families of asymmetric quantum stabilizer codes from pairs of nested classical codes. For instance, we derive asymmetric codes using a combination of Bose–Chaudhuri–Hocquenghem (BCH) and finite geometry low-density parity-check (LDPC) codes. We show that the asymmetric quantum codes offer two advantages, namely to allow a higher rate without sacrificing performance when compared with symmetric codes and vice versa to allow a higher performance when compared with symmetric codes of comparable rates. Our approach is based on a CSS construction that combines BCH and finite geometry LDPC codes.

## 1. Introduction

In many quantum mechanical systems, the mechanisms for the occurrence of bit- and phase-flip errors are quite different. In a recent work, Ioffe & Mézard (2007) postulated that quantum error correction should take into account this asymmetry. The main argument given by Ioffe & Mézard (2007) is that most of the known quantum computing devices have relaxation times (*T*_{1}) that are approximately one to two orders of magnitude larger than the corresponding dephasing times (*T*_{2}). In general, relaxation leads to both bit- and phase-flip errors, whereas dephasing only leads to phase-flip errors. This large asymmetry between *T*_{1} and *T*_{2} suggests that bit-flip errors occur less frequently than phase-flip errors and a well-designed quantum code would exploit this asymmetry of errors to provide better performance. In fact, this observation and its consequences for quantum error correction, especially quantum fault tolerance, has been studied by several authors (Evans *et al*. 2007; Stephens *et al*. 2007; Aliferis & Preskill 2008).

Our goal is to construct quantum codes that exploit asymmetry. The focus of the present paper is on quantum memory and communication; at present, we do not consider the issue of fault tolerance. As a concrete illustration of this, we consider the amplitude damping and dephasing channel. For this channel, we can compute the probabilities of bit and phase flips in closed form. In particular, by giving explicit expressions for the ratio of these probabilities in terms of the ratio *T*_{1}/*T*_{2}, we show how the channel asymmetry arises.

### (a) Related work

Several recent papers discuss the situation of quantum error correction in the presence of an asymmetric error model that gives a strong bias towards certain errors.

Aliferis & Preskill (2008) gave a construction based on the concatenation of a repetition code with any other quantum code to get asymmetric quantum codes for biased noise. While this has the advantage that universal fault-tolerant quantum computation is possible, we expect the codes constructed in this way to have a lower rate than the ones constructed in the present paper. On the other hand, it is not known whether the codes proposed in the present paper admit a set of universal fault-tolerant gates that preserve the channel asymmetry. Evans *et al*. (2007) used symmetric Calderbank–Shor–Steane (CSS) codes with asymmetric error-correction strategy to obtain an advantage for fault-tolerant quantum error correction over a symmetric strategy. The asymmetry in this case comes from higher frequency of syndrome measurements for the *X*-only generators as compared with the *Z*-only generators. Stephens *et al*. (2007) used a combination of a symmetric code along with an asymmetric code to achieve fault-tolerant computation. In this approach, one has to use fault-tolerant circuits to switch between the symmetric and asymmetric encodings. This idea may be applicable in the present context also, though further study is needed. But we mention that our constructions include as special cases symmetric stabilizer codes for which fault-tolerant universal computation is possible. Some of them based on low-density parity-check (LDPC) codes are of independent interest and can be useful even in the absence of an asymmetric channel.

The paper by Ioffe & Mézard (2007) is closest to our work regarding the methods used to construct asymmetric quantum codes as both employ a CSS construction having a classical LDPC code for the *Z*-errors and a classical Bose–Chaudhuri–Hocquenghem (BCH) code for the *X*-errors. However, as we show in §4*b*, we employ a different approach to construct the LDPC code that allows us to have more control on the degree profile of the LDPC code. Arguably, this gives an advantage regarding not only the structure of these codes but also their performance, since similar to the classical case, our codes do not show an error floor for very small probabilities of channel errors.

It should also be noted that the performance of symmetric quantum codes for some specific quantum codes, such as a [[5, 1, 3]] or [[7, 1, 3]] code, over arbitrary (not necessarily symmetric) Pauli channels has been studied by Rahn *et al*. (2002). However, contrary to the present paper in which the goal is to exploit channel asymmetries for the code design, in this paper, the goal is to characterize the performance of a given code under variation of the error weights and to find the channel under which the given code has optimal performance. Finally, in a recent development, Fletcher *et al*. (2008) studied adaptive quantum error-correction strategies in which the optimal error-correction strategy is found for a given channel using semi-definite programming. These techniques have been applied to the case of asymmetric channels that arise from amplitude damping channels. The amplitude damping model was first studied from the point of view of quantum error correction by Leung *et al*. (1997), where an approximate quantum code that encodes one qubit into four qubits was given. This code can also be seen as an *exact* quantum error-correcting code for a certain choice of errors, namely amplitude damping errors *X*+i*Y* and bit-flip/phase damping errors *Z* (B. Zeng 2008, personal communication). There is a physically arising asymmetry between the error probabilities for these two types of errors; see also appendix A for a derivation.

### (b) Organization of this paper

In §2, we provide the necessary background on quantum channels and give a motivation for asymmetric quantum channels, i.e. noise models that show a significant bias towards specific types of errors. We consider the concrete example of the noise model given by amplitude damping and dephasing. This serves as motivation of asymmetric channels and has the advantage that the amount of asymmetry in the bit flip in phase-flip probabilities can be quantified easily and can be related to physical quantities such as *T*_{1} and *T*_{2}.

Next, in §3, we explain why our focus in this paper will be asymmetric codes that are obtained from the CSS construction. After briefly sketching the ideas of asymmetric codes, we derive some bounds on the parameters of these codes. Similar to the case of standard quantum codes, which we will refer to as symmetric quantum codes as they are not designed to exploit any bias towards one specific error, it is possible to derive good upper bounds using linear programming.

We then address the question of how to construct asymmetric quantum codes. In §4, we show that, in general, a family of nested classical codes is well suited to constructing such asymmetric quantum codes. We illustrate this for a few well-known families of codes, namely Reed–Muller (RM) codes and BCH codes. Then, we propose an alternative approach to Ioffe & Mézard (2007) and use a finite geometry LDPC code and BCH code to construct an asymmetric stabilizer code.

The performance of asymmetric codes is the subject of §5. We simulate the performance of several examples of asymmetric codes constructed by the methods described in this paper in terms of the resulting block error rate versus the probability of channel errors. Simulations are carried out for various choices of channel asymmetries and codes. We explain why a modification of the standard iterative decoding algorithms known from classical LDPC codes is required as, in the quantum case, no (soft) channel information is available. We present a suitable modification of the iterative decoding algorithm that starts with information in the check nodes and then proceeds in a similar fashion to the classical hard-decision bit-flipping algorithm.

The present paper is an expanded version of Sarvepalli *et al*. (2008) and contains some of the results presented therein.

## 2. Background on quantum error models

Recall that a quantum channel is a completely positive trace-preserving map (Nielsen & Chuang 2000). Such maps can be written in Kraus operator form, where the action of the channel on a given input state *ρ* is described as follows: , where the completeness relation holds. The operators *A*_{i} are the Kraus operators of the channel. A special case of a channel on one qubit arises if the Kraus operators are simply given by the Pauli matrices, i.e. a state *ρ* is mapped to(2.1)with(2.2)Such a channel is called a *Pauli channel*. In a Pauli channel, one has independent probabilities *p*_{x}, *p*_{y}, *p*_{z} (subject to *p*_{x}+*p*_{y}+*p*_{z}≤1) that an input qubit in state *ρ* is subjected to a Pauli *X*, *Y* or *Z* error, respectively.

As an example of a channel that arises in the study decoherence in concrete physical systems, we consider the combined *amplitude damping and dephasing channel* . Important parameters for the noise process underlying this channel are the relaxation time *T*_{1} and dephasing time *T*_{2}. Suppose the channel acts on a single-qubit state *ρ*=(*ρ*_{ij})_{i,j∈{0, 1}} for a time *t*. This yields the resulting density matrixWe would like to determine the probability *p*_{x}, *p*_{y} and *p*_{z}, such that an *X*-, *Y*- or *Z*-error occurs in a combined amplitude damping and dephasing channel. However, it turns out that this question is not well posed, since is not a Pauli channel, i.e. it cannot be written in the form (2.1). However, we can obtain a Pauli channel by conjugating the channel by Pauli matrices and averaging over the results. The channel is called the Pauli twirl of and is explicitly given by

Twirling (DiVincenzo *et al*. 2002; Emerson *et al*. 2005; Dankert *et al*. 2006) is used in quantum information theory as a tool to map quantum channels to simpler ones, while preserving many interesting features of the initial channel. Twirling has been used, for instance, for the task of estimating the average fidelity of a quantum gate and for the task of determining more general features of channels (Emerson *et al*. 2007), as well as for the task of identifying codes for general quantum channels (Silva *et al*. 2007). In our situation, we apply the Pauli twirl to map the channel to a Pauli channel.

*Given a combined amplitude damping and dephasing channel* *as above*, *the associated Pauli-twirled channel is of the form**where* *and* . *In particular*,*If t*≪*T*_{1}, *then we can approximate this ratio as* 2*T*_{1}/*T*_{2}−1.

The proof of this theorem is straightforward but technical and is given in appendix A. From theorem 2.1, it follows that an asymmetry in the *T*_{1} and *T*_{2} times does translate into an asymmetry in the occurrence of bit- and phase-flip errors. Note that *p*_{x}=*p*_{y}, indicating that the *Y*-errors are as unlikely as the *X*-errors. We shall refer to the ratio *p*_{z}/*p*_{x} as the channel asymmetry and throughout the paper shall denote it by *A*. Please note in some papers the asymmetry is quantified in terms of the ratio (*p*_{z}+*p*_{y})/(*p*_{x}+*p*_{y}).

## 3. Asymmetric quantum codes: basics and bounds

Asymmetric codes use the fact that the phase errors are much more likely than the bit-flip errors or the combined bit–phase-flip errors. Therefore, the code has different error-correcting capabilities for handling different types of errors. We require the code to correct many phase errors but it is not required to handle the same number of bit-flip errors. If we assume a CSS code, then we can meaningfully speak of *X*- and *Z*-distances. A CSS stabilizer code that can detect all *X*-errors up to weight *d*_{x}−1 is said to have an *X*-distance of *d*_{x}. Similarly, if it can detect all *Z*-errors up to weight *d*_{z}−1, then it is said to have a *Z*-distance of *d*_{z}. We shall denote such a code by [[*n*, *k*, *d*_{x}/*d*_{z}]]_{q} to indicate it as an asymmetric code. We could also view this code as an [[*n*, *k*, min{*d*_{x}, *d*_{z}}]]_{q} stabilizer code. Further extension of these metrics to an additive non-CSS code is an interesting problem, but we will not go into the details here. We would like to point out that Steane (1996) had earlier used a similar notation to distinguish the two distances. He also suggested that efficient codes can be designed should we be in possession of more information about the noise processes. Though the notion of asymmetric non-binary quantum codes needs further treatment, the idea of non-binary CSS is well understood. Some of the results are given for a non-binary alphabet.

We will exclusively use the CSS construction (Steane 1996; Calderbank *et al*. 1998) to construct asymmetric quantum codes. Recall that in the CSS construction a pair of codes are used, one for correcting the bit-flip errors and the other for correcting the phase-flip errors. Our choice of these codes will be such that the code for correcting the phase-flip errors has a larger distance than the code for correcting the bit-flip errors. We restate the CSS construction in a form convenient for asymmetric stabilizer codes.

*Let C*_{x}, *C*_{z} *be linear codes over* *with the parameters* [*n*, *k*_{x}]_{q} *and* [*n*, *k*_{z}]_{q}, *respectively*. *Let* . *Then*, *there exists an* [[*n*, *k*_{x}+*k _{z}*−

*n*,

*d*

_{x}/

*d*

_{z}]]

_{q}

*asymmetric quantum code*,

*where*

*and*.

If in the above construction *d*_{x}=wt(*C*_{x}) and *d*_{z}=wt(*C*_{z}), then we say that the code is pure. In this context, we can give a bound for CSS-type pure asymmetric stabilizer codes similar to the quantum Singleton bound.

*A pure asymmetric* [[*n*, *k*, *d*_{x}/*d*_{z}]]_{q} *CSS code satisfies*

Assume that the asymmetric code is constructed using lemma 3.1, then wt(*C*_{x})=*d*_{x} and wt(*C*_{z})=*d*_{z}. By the classical Singleton bound, and . Then, . It follows *k*≤*n*−*d*_{x}−*d*_{z}+2.

The bound in lemma 3.2 can be extended for all -linear asymmetric CSS-type codes.

*Any CSS-type* -*linear* [[*n*, *k*, *d*_{x}/*d*_{z}]]_{q} *CSS-type code satisfies*(3.1)

Let us assume that the asymmetric CSS code was constructed using lemma 3.1. Let be the complement of in *C*_{x}, i.e. a subcode of *C*_{x}, such that the span of and is *C*_{x}. Similarly, let be the complement of in *C*_{z}. Let and . We have . Now, the linearity of the stabilizer code implies that we can choose to be all zeros in *k*_{b} columns, because we can perform Gaussian elimination using to get rid of the non-zero elements in *k*_{b} columns. In effect, is a code of length *n*−*k*_{b}. Now the classical Singleton bound implies that . The minimum distance of must be at least *d*_{x} because it is a subcode of and we know that . Similarly, we can show that , where . It follows thatBut , thereforeNow using the fact that , we have , i.e. *k*≤*n*−*d*_{x}−*d*_{z}+2. ▪

This bound seems to imply that if there was an asymmetry in the channel, then using asymmetric quantum codes we could potentially gain in rate. It would be interesting to extend this bound to all asymmetric stabilizer codes linear or otherwise. The (quantum) Singleton bound, in general, is not very tight, especially for large lengths. In this context, the linear programming bounds turn out to be more useful. We shall derive some linear programming bounds for CSS-type asymmetric stabilizer codes.

*If an* [[*n*, *k*, *d*_{x}/*d*_{z}]]_{2} *asymmetric CSS stabilizer code with k*>0 *exists*, *then there exists a solution to the optimization problem*: *maximize* *subject to the constraints**where the coefficients A*_{j}, , *B*_{j} *and* *are integrals and K*_{j}(*r*) *denotes the Krawtchouk polynomial*(3.2)

If an [[*n*, *k*, *d*_{x}/*d*_{z}]]_{2} asymmetric stabilizer code exists, then by lemma 3.1, there exists classical codes . Let the weight distributions of and be given by *A*_{i} and *B*_{i}, respectively, where 0≤*i*≤*n*. If we let , then this means and since , it follows that . We restrict the range of 0<*k*′<*n*−*k* to ensure that *d*_{x}, *d*_{z}>1. The weight distributions of *C*_{x} and *C*_{z} are given by the MacWilliams duality relations (MacWilliams & Sloane 1977). These give us(3.3)and(3.4)

Since and , we must have and , for 0≤*j*≤*n*. As the quantum code has *X*-distance *d*_{x}, all vectors of weight less than *d*_{x} in *C*_{x} must be in , giving us , for 1≤*j*≤*d*_{x}−1. Similarly, all vectors of weight less than *d*_{z} in *C*_{z} must be in and we get , for 1≤*j*≤*d*_{z}−1. ▪

In order to implement the above constraints as a linear programming problem, we must fix the value of *k*′. Then, the above constraints reduce to *n*−*k*−1 instances of a linear programming problem. An [[*n*, *k*, *d*_{x}/*d*_{z}]] code will not exist if none of the instances have a solution. It is possible that the code might not exist even if some instance has a solution.

Using the linear programming bounds, we were able to show that there can exist a [[15, 1, 3/7]] code. This code can be constructed using two BCH codes. Further details about this code are given in §5. Note that there does not exist a [[15, 1, 7]] stabilizer code.

One of the referees pointed out that a [[13, 1, 3/5]] exists. We were, however, unable to construct a smaller code, even though the linear programming bounds indicate that a [[12, 1, 3/5]] may exist. Our interest in these small codes is due to the fact that small codes are easier to analyse and study, and might perhaps provide insight into asymmetric quantum error correction. It would be an interesting problem to show its existence or non-existence.

## 4. Asymmetric quantum codes: constructions

### (a) Construction from families of nested codes

Our first construction makes use of RM codes (for an introduction see Huffman & Pless 2003, pp. 33–36). Recall that a RM code of order *r* and length 2^{m} has the parametersLet us denote an *r*th order RM code as . RM codes have the following interesting properties of relevance for us:

and

if

*r*_{1}≤*r*_{2}.

We shall call a family of codes that satisfy a property as (ii) with respect to some code parameter *nested codes*. The BCH codes are also a family of nested codes. As a first example, we construct asymmetric quantum codes based on the nested family of RM codes. The resulting codes are not new, they have been already constructed by Steane (1999*b*); in fact, the use of RM codes for quantum error correction was suggested earlier by Knill *et al*. (1996).

*Let* 0≤*r*_{1}<*r*_{2}<*m*. *Then*, *there exists an**asymmetric RM stabilizer code*.

Let and . Then, the code follows from the application of lemma 3.1. Note that the dimension of the quantum code iswhere the last equality follows from the fact *r*_{1}<*r*_{2}. With respect to the distance, we have , because the . Similarly, . ▪

These codes illustrate the trade-offs involved in the design of asymmetric stabilizer codes. In order to have large asymmetry in the distance, we need *d*_{x}/*d*_{z} to be very small. In this case, we need large. In order to get a large rate, we will require that the difference between *r*_{2}−*r*_{1} is also large.

*Let* , *then there exists an**code which can be turned into an**asymmetric code*, *where*

Under the conditions on *r*, we can choose and apply lemma 3.1, then the stabilizer code follows. If we choose , then we can convert the stabilizer code into the asymmetric stabilizer code with the given parameters. ▪

The preceding result indicates that asymmetry can be exploited to get higher rates compared with a symmetric stabilizer code.

In table 1, we show the gains in rate as one allows for more and more asymmetry.

We denote a *q*-ary narrow-sense BCH code of length *n* and design distance *δ* by . We drop *n* in the notation if the code is primitive, i.e. *n*=*q*^{m}−1, where *m*=ord_{n}(*q*) is the multiplicative order of *q* modulo *n*. For binary codes, we suppress *q* also for convenience. If *δ*≤2^{⌈m/2⌉}−1, we can compute the dimension of the BCH code exactly as 2^{m}−1−*mt* (see MacWilliams & Sloane 1977, p. 263).1 In the following, we assume that the design distances of binary BCH codes are odd.

*Let m*≥2 *and* 2≤*δ*_{1}<*δ*_{2}<*δ*_{max}, *where δ*_{max}=2^{⌈m/2⌉}−1 *and δ*_{i}≡1 mod 2. *Then*, *there exists an**asymmetric BCH stabilizer code*, *where d*_{x}≥*δ*_{1} *and d*_{z}≥*δ*_{max}+1.

In this case, we choose and . Under the restrictions on *δ*_{1} and *δ*_{2}, we can compute the dimension of the BCH codes explicitly. The dimension of (*δ*)^{⊥} is given by *m*(*δ*−1)/2, assuming odd *δ*. By lemma 3.1, we can then compute the dimension of the quantum code as *m*(*δ*_{2}−1)/2−*m*(*δ*_{1}−1)/2=*m*(*δ*_{2}−*δ*_{1})/2.

We have and . The last inequality follows from the fact that the distance of (*δ*_{2})^{⊥} code is at least *δ*_{max}+1, as shown by lemma 10 of Aly *et al*. (2007). ▪

Suppose we let *m*=10 and vary *δ*_{1} and *δ*_{2}. Some of the codes that can be constructed are given in table 2.

Alternatively, we could consider dual containing BCH codes to construct stabilizer codes. In this case, it is easier to see that the gain in rate is proportional to the loss in the distance for the bit-flip channel.

*Let n*=2^{m}−1, *δ*_{max}=2^{⌈m/2⌉}−1 *and δ*=2*t*+1≤*δ*_{max}. *Then*, *there exists an* [[*n*, *n*−*m*(*δ*−1), ≥*δ*]]_{2} *stabilizer code that can be converted to an* [[*n*, *n*−*m*(*δ*−1)+*mΔ*/2, *d*_{x}/*d*_{z}]]_{2} *asymmetric stabilizer code*, *where* 0≤*Δ*=2*l*≤*δ*−2 *and d*_{x}≥*δ*−*Δ* *and d*_{z}≥*δ*.

Under the restrictions on *δ*, we have (*δ*)^{⊥}⊆(*δ*) (see lemma 1 of Steane 1999*a*). Then, the stabilizer code is obtained by choosing *C*_{x}=*C*_{z}=(*δ*) in lemma 3.1. If *C*_{x} is chosen to be (*δ*−*Δ*), then we get the asymmetric stabilizer code. ▪

These results seem to indicate, once again, that asymmetry, in general, can lead to a rate gain. In the case of the BCH stabilizer codes constructed above, it appears that the rate gain is linearly proportional to the reduction in the distance of the code used for correcting bit-flip errors.

In general, any family of nested codes can lead to a class of asymmetric stabilizer codes. The main obstacle to such a method is usually the knowledge of the dual distances, a knowledge of which is required to determine the error-correcting capability of the quantum code. However, algebraic codes have this nice structure of being nested, and within certain ranges it is also possible to lower bound the distances including the dual distances. So, while we cannot claim a truly asymmetric code because of our lack of knowledge of these distances, we can certainly form a class of codes quite suitable for the asymmetric channels.

### (b) Construction from dual pairs of LDPC and BCH codes

Nested codes are not the only method to construct asymmetric codes. Ioffe & Mézard (2007) used a combination of BCH and LDPC codes to construct asymmetric codes. The intuition being that the stronger LDPC code should be used for correcting the phase errors and the BCH code can be used for the infrequent bit flips. This essentially reduces to finding a good LDPC code such that the dual of the LDPC code is contained in the BCH code. They solve this problem by randomly choosing code words in the BCH code which are of low weight (so that they can be used for the parity-check matrix of the LDPC code). However, their method is a little ad hoc and it is not clear how good is the resulting LDPC code. For instance, the degree profiles of the resulting code are irregular and there is little control over the final degree profiles of the code. It was claimed by Ioffe & Mézard (2007) that their codes can be analysed using the traditional methods of analysis for the LDPC codes. But there are many questions that must be answered before it can be fully justified. For instance, it is not apparent what ensemble or degree profiles one will use for performing this analysis.

We consider using LDPC codes to construct asymmetric stabilizer codes. Part of the reason being that these codes are among the best classical codes with efficient decoding algorithms. It should be noted that several classes of quantum LDPC codes have been proposed (MacKay *et al*. 2004; Camara *et al*. 2007; Hagiwara & Imai 2007). So far, however, the structure of quantum LDPC codes in general, including their decoding algorithms, is not well understood. For some time it was even doubtful whether quantum LDPC codes exist at all, since a simple observation shows, for instance, that quantum LDPC codes constructed as stabilizer codes must necessarily have four cycles in their Tanner graph, but see the work of Hagiwara & Imai (2007) for an interesting work around. To circumvent this problem, we are interested in families of quantum LDPC codes which have the property to tolerate large numbers of four cycles without affecting the performance of the decoding algorithm too adversely.

More precisely, we propose two families of quantum codes based on LDPC codes. In the first case, we use LDPC codes for both the *X*- and *Z*-channels. We will need the following facts about generalized RM codes and finite geometry LDPC codes.

#### (i) Some facts about finite geometry LDPC codes

In this section, we will briefly review finite geometry LDPC codes (Kou *et al*. 2001; Tang *et al*. 2005). Let us denote by EG(*m*, *p*^{s}) the Euclidean finite geometry over consisting of *p*^{ms} points. For our purposes, it only suffices to use the fact that this geometry is equivalent to the vector space . A *μ*-dimensional subspace of or its coset is called a *μ-flat*. We can describe a *μ*-flat by the following equation:(4.1)where the are linearly independent. The 0-flats and 1-flats are the familiar points and lines. Assume that 0≤*μ*_{1}<*μ*_{2}≤*m*. Then, we denote by *N*_{EG}(*μ*_{2}, *μ*_{1}, *s*, *p*) the number of *μ*_{1}-flats in a *μ*_{2}-flat and by *A*_{EG}(*m*, *μ*_{2}, *μ*_{1}, *s*, *p*), the number of *μ*_{2}-flats that contain a given *μ*_{1}-flat. These are given by (see Tang *et al*. 2005)(4.2)and(4.3)where *q*=*p*^{s}. Index all the *μ*_{1}-flats from *i*=1 to *n*=*N*_{EG}(*m*, *μ*_{1}, *s*, *p*) as *F*_{i}. Let be a *μ*_{2}-flat in EG(*m*, *p*^{s}). Then, we can associate an incidence vector to with respect to the *μ*_{1} flats as follows:Index the *μ*_{2}-flats from *j*=1 to *J*=*N*_{EG}(*m*, *μ*_{2}, *s*, *p*). Construct the *J*×*n* matrix , whose rows are the incidence vectors of all the *μ*_{2}-flats with respect to the *μ*_{1}-flats. This matrix is also referred to as the incidence matrix. Then, the type-I Euclidean geometry code from *μ*_{2}- and *μ*_{1}-flats is defined to be the null space (i.e. the Euclidean dual) of the -linear span of . This is denoted as . Let . Then, the type-II Euclidean geometry code is defined to be the null space of . Let us now consider the *μ*_{2}- and *μ*_{1}-flats that do not contain the origin of EG(*m*, *p*^{s}). Now form the incidence matrix of the *μ*_{2}-flats with respect to the *μ*_{1}-flats not containing the origin. The null space of this incidence matrix gives us a quasi-cyclic code in general, which we denote by .

#### (ii) Some facts about the generalized Reed–Muller codes

Before we proceed further, we recall some salient facts about the generalized RM codes (Kasami *et al*. 1968*a*). Let *α* be a primitive element in . The cyclic generalized RM code of length *q*^{m}−1 and order *ν* is defined as the cyclic code with the generator polynomial, whose roots *α*^{j} satisfy 0<*j*≤*m*(*q*−1)−*ν*−1. The generalized RM code is the singly extended code of length *q*^{m}. It is denoted as GRM_{q}(*ν*, *m*). The dual of a GRM code is also a GRM code (Kasami *et al*. 1968*a*; Assmus & Key 1998; Blahut 2003). It is known that(4.4)

Let *C* be a linear code over . Then, we define , the *subfield subcode* of *C* over as the code words of *C*, which are entirely in (see Huffman & Pless 2003, pp. 116–120). Formally, this can be expressed as(4.5)Let . Then, the *trace code* of *C* over is defined as(4.6)where . There are interesting relationships between the trace code and the subfield subcode. One of which is the following result, which we will need later.

*Let* . *Then* , *the subfield subcode of C is contained in* , *the trace code of C*. *In other words,*

Let and . Then, as . Since trace is a surjective form, there exists some , such that . This implies that . Since *c* is an arbitrary element in , it follows that . ▪

The other relation due to Delsarte is the following.

**(****Delsarte 1975****).** *Let* . *Then,*

Let *q*=*p*^{s}, then the Euclidean geometry code of order *r* over EG(*m*,*p*^{s}) is defined as the dual of the subfield subcode of GRM_{q}((*q*−1)(*m*−*r*−1),*m*) (Blahut 2003, p. 448). The type-I LDPC code of code is an Euclidean geometry code of order *μ*−1 over EG(*m*, *p*^{s}) (see Tang *et al*. 2005). Hence, its dual is the subfield subcode of GRM_{q}((*q*−1)(*m*−*μ*),*m*) code. In other words,(4.7)Furthermore, Delsarte's result (lemma 4.8) states thatHence, code can also be related to as(4.8)

In theorem 4.9, we use all these facts together to construct a family of asymmetric stabilizer LDPC codes.

*Let p be a prime*, *with q*=*p*^{s} *and s*≥1, *m*≥2. *Let* 1<*μ*_{z}<*m and m*−*μ*_{z}+1≤*μ*_{x}<*m*. *Then, there exists an**asymmetric EG LDPC code*, *where**d*_{x}≥*A*_{EG}(*m*, *μ*_{x}, *μ*_{x}−1, *s*, *p*)+1 *and d*_{z}≥*A*_{EG}(*m*, *μ*_{z}, *μ*_{z}−1, *s*, *p*)+1.

Let us choose . Then, from equation (4.8) we haveBy lemma 4.7, we know thatwhere the last inclusion follows from the nesting property of the generalized RM codes. For any order *μ*_{x} such that *m*−*μ*_{z}+1≤*μ*_{x}<*m*, let . Then *C*_{x} is an LDPC code whose dual is contained in *C*_{z}. Thus, we can use lemma 3.1 to form an asymmetric code with the parametersThe distance of *C*_{z} and *C*_{x} are lower bounded as *d*_{x}≥*A*_{EG}(*m*, *μ*_{x}, *μ*_{x}−1, *s*, *p*)+1 and *d*_{z}≥*A*_{EG}(*m*,*μ*_{z},*μ*_{z}−1,*s*,*p*)+1 (see Tang *et al*. 2005). ▪

In the construction just proposed, we should choose *C*_{x} to be a larger code compared with *C*_{z}, so that *C*_{z} is a stronger code. We have the construction over a non-binary alphabet, although in the context of asymmetric quantum codes, one might be more interested in the case *p*=2.

We briefly turn our attention back to the (symmetric) depolarizing channel. It turns out that the presented LDPC codes, which are designed for asymmetric channels, will, in general, not perform equally well on the depolarizing channel. In fact, constructing good quantum LDPC codes for the depolarizing channel remains a difficult problem and a satisfactory solution is yet to be advanced. However, we point out in corollary 4.10 to theorem 4.9 that, under certain conditions on the rate of the desired code, it is possible to construct quantum LDPC codes also for the symmetric depolarizing channel.

*Let p be a prime*, *with q*=*p*^{s} *and s*≥1, *m*≥2. *Let* ⌈(*m*+1)/2⌉≤*μ*<*m*. *Then, there exists an* [[*p*^{ms}, 2*k*−*p*^{ms}, *d*]]_{p} *symmetric EG LDPC code*, *where* . *For the distance*, *d*≥*A*_{EG}(*m*, *μ*, *μ*−1, *s*, *p*)+1 *holds*.

Our next construction is an alternative to the method proposed by Ioffe & Mézard (2007). Now we shall make use of the cyclic finite geometry codes. Our goal will be to find a BCH code whose dual is contained in a cyclic Euclidean geometry LDPC code. First, we need the notion of *q*-ary weight. Let 0≤*h*<*q*^{m}, then we define(4.9)If *h*≥*q*^{m}, then we compute *W*_{q}(*h*) as the weight of *h* mod *q*^{m}−1.

*Let C be the code* *and δ*≤*δ*_{0}=*p*^{μs}−1. *Then, there exists an**asymmetric stabilizer code*, *where d*_{z}≥*A*_{EG}(*m*, *μ*, *μ*−1, *s*, *p*) *and d*_{x}≥*δ*.

For proving this theorem, we need the cyclic structure of . Let *α* be a primitive element in . Then, the roots of generator polynomial of are given by Kasami & Lin (1971, theorem 6), see also Kasami *et al*. (1968*b*) and Lin & Costello (2004),where *W*_{q}(*h*) is as defined in equation (4.9). The code is actually an (*μ*−1,*p*^{s}) Euclidean geometry code. The roots of the generator polynomial of the dual code are given byIn fact, the dual code is the even-like subcode of a primitive polynomial code of length *p*^{ms}−1 over and order *m*−*μ*. By Kasami *et al*. (1968*b*, theorem 6), the generator polynomial of the polynomial code has the rootsThus, *Z*^{⊥}=*Z*_{p}∪{0}. Now by Kasami & Lin (1971, theorem 6), *Z*_{p} and therefore *Z*^{⊥} contain the sequence of consecutive roots, *α*, *α*^{2},…,, whereSimplifying, we see that *R*=0 and *Q*=*μ* giving *δ*_{0}=*p*^{μs}−1. It follows thatThus, we have solved the problem of construction of the asymmetric stabilizer codes in dual fashion to that of Ioffe & Mézard (2007). Instead of finding an LDPC code whose parity-check matrix is contained in a given BCH code, we have found a BCH code whose parity-check matrix is contained in a given finite geometry LDPC code. Choosing any BCH code whose design distance is less than *p*^{μs}−1 gives a BCH code, which contains the dual of the finite geometry LDPC code . Thus, we can apply lemma 3.1 to obtain the code stated in the statement of the theorem. ▪

In what follows, we give a small example to illustrate this construction.

Let *m*=*s*=*p*=2 and *μ*=1. Then, is a cyclic code whose generator polynomial has roots given byAs there are four consecutive roots and |*Z*|=8, it defines a [15, 7, ≥5] code. The roots of the generator polynomial of the dual code are given byWe see that *Z*^{⊥} has two consecutive roots excluding 1; therefore, the dual code is contained in a narrow-sense BCH code with design distance 3. Note that *p*^{μs}−1=3. Thus, we can choose *C*_{x}=(3) and and apply lemma 3.1 to construct a [[15, 3, 3/5]]_{2} asymmetric code.

We can also state the above construction in a dual fashion, i.e. given a primitive BCH code of design distance *δ*, find an EG LDPC code whose dual is contained in it. It must be pointed out that in the case of asymmetric codes derived from LDPC codes, the asymmetry factor *d*_{x}/*d*_{z} is not as indicative of the code performance as in the case of bounded distance decoders. For *m*=*p*=2, we can derive explicit relations for the parameters of the codes.

*Let* *and δ*=2*t*+1≤2^{s}−1. *Then, there exists an**asymmetric stabilizer code*.

The parameters of *C* are [2^{2s}−1,2^{2s}−3^{s},2^{s}+1]_{2} (see Lin & Costello 2004). Since *C*^{⊥} is contained in a BCH code of length 2^{2s}−1 whose design distance *δ*≤2^{s}−1, we can compute the dimension of the BCH code as 2^{2s}−1−*s*(*δ*−1) (see MacWilliams & Sloane 1977, corollary 8). By lemma 3.1, the quantum code has the dimension 2^{2s}−3^{s}−*s*(*δ*−1). ▪

For *m*=*p*=2 and *s*=4, we can obtain a [255, 175, 17] LDPC code. We can choose any BCH code with design distance *δ*≤2^{4}−1=15 to construct an asymmetric code. Possible codes are given in table 3.

The previous method of using a BCH code and a LDPC code can also be used in conjunction with any LDPC code that is cyclic. In particular, LDPC codes derived from projective finite geometry are amenable to this approach. First, let us recall some facts about projective geometries. An *m*-dimensional projective geometry is denoted as PG(*m*, *p*^{s}). The points in PG(*m*, *p*^{s}) can be put in correspondence with the non-zero elements of . A *μ*-flat in PG(*m*, *p*^{s}) is described by(4.10)and are linearly independent. Any non-zero (*m*+1)-tuple is a point in the projective geometry, PG(*m*, *p*^{s}). Two tuples are equivalent if one is non-zero () scalar multiple of other. Consequently, there are *n*=(*p*^{(m+1)s}−1)/(*p*^{s}−1) points in PG(*m*, *p*^{s}). Let *α* be a primitive element in and *β*=*α*^{n}. Then, *β* is a primitive element of . A point in PG(*m*, *p*^{s}) can also be represented as *α*^{i} for some power of *α*. Since scalar multiples of *α*^{i} denote the same point, we denote this equivalence by using (*α*^{i}), where and 0≤*i*≤*n*−1. Let 0≤*μ*_{1}<*μ*_{2}≤*m*, then we define *N*_{PG}(*μ*_{2}, *μ*_{1}, *s*, *p*) to be the number of *μ*_{1}-flats that are contained in a given *μ*_{2}-flat and *A*_{PG}(*μ*_{2}, *μ*_{1}, *s*, *p*) to be the number of *μ*_{2}-flats that contain a given *μ*_{1}-flat. These are given as(4.11)and(4.12)Index the *μ*_{1}-flats in PG(*m*, *p*^{s}) as *F*_{j} from *j*=1 to *N*=*N*_{PG}(*μ*_{2}, *μ*_{1}, *s*, *p*). The incidence vector associated with a *μ*_{2}-flat with respect to the *μ*_{1}-flats is given (as in the Euclidean case) byIndex all the *μ*_{2}-flats from *i*=1 to *J*=*N*_{PG}(*m*, *μ*_{2}, *s*, *p*) and form the *J*×*N* incidence matrix from the incidence vectors of all the *μ*_{2}-flats. The null space of the matrix defines the type-I projective geometry LDPC code. With this preparation, we are ready to construct asymmetric BCH–LDPC stabilizer codes from projective geometries.

*Let* , *n*=(*p*^{(m+1)s}−1)/(*p*^{s}−1) *and δ*≤*δ*_{0}=(*p*^{(μ+1)s}−1)/(*p*^{s}−1). *Then, there exists an**asymmetric stabilizer code*, *where k*_{x}=dim _{p}(*δ*, *n*), , *d*_{z}≥*A*_{EG}(*m*, *μ*, *μ*−1, *s*, *p*) *and d*_{x}≥*δ*.

Let *α* be a primitive element of . The code is a cyclic code with *α*^{h} as roots of its generator polynomial if and only if *p*^{s}−1 divides *h* and for some 0≤*j*≤*m*−*μ* (see Tang *et al*. 2005, eqn (27)). In other words, the roots are given byThe roots of the dual code are given byNow by Kasami *et al*. (1968*b*, theorem 11), *Z*^{⊥} contains a sequence of *δ*_{0} consecutive roots given by in *Z*^{⊥}, where and *δ*_{0} is given as *δ*_{0}=((*R*+1)*q*^{Qs}+1)/(*p*^{s}−1), whereIt follows that *R*=0 and *Q*=*μ*+1. Therefore, there exists a BCH code, *D* of design distance *δ*≤*δ*_{0}=(*p*^{(μ+1)s}−1)/(*p*^{s}−1) that contains the dual of the LDPC code. Additionally, observe that the order of *β* is ord(*α*)/gcd(*p*^{s}−1, ord(*α*))=(*p*^{(m+1)s}−1)/gcd(*p*^{s}−1, *p*^{(m+1)s}−1)=*n*. Therefore, *D* is a (non-primitive) narrow-sense BCH code. In conjunction with lemma 3.1, and give the code with the parameters stated in the theorem. ▪

It will be useful to have exact expressions for the dimensions of the code constructed using theorem 4.15. In general, these expressions are fairly complicated, but for the special case of *m*=2 and *μ*=1, we can compute explicitly. Additionally, the following fact (Aly *et al*. 2007, theorem 10) on the dimension of non-primitive BCH codes is required.

**(****Aly et al. 2007**

**).**

*Let q be a power of prime and*gcd(

*n*,

*q*)=1

*with*ord

_{n}(

*q*)=

*m*.

*Then a narrow-sense BCH code of length*

*over*

*with designed distance δ in the range*

*has dimension*

Putting all these together, we get corollary 4.17.

*Let* , *n*=2^{2s}+2^{s}+1 *and δ*≤2^{s/2}+1. *Then there exists an asymmetric**stabilizer code*.

From Kou *et al*. (2001, eqn (21)), we know that is a [*n*, *n*−3^{s}−1, 2^{s}+2]_{2} code. It can be easily verified that the narrow-sense binary BCH code containing the dual of *C* satisfies the requirements of lemma 4.16 and is an code. The asymmetric stabilizer code now follows from theorem 4.15. ▪

## 5. Performance results

We now give the performance results of some of the codes constructed in §4. First, we will give the details about the channel model and how the simulations are performed.

Basically, asymmetric stabilizer codes can give us two benefits. Firstly, over an asymmetric quantum channel, they can give lower error rates compared with symmetric codes. We assume in this case we are comparing codes of same rates. Secondly, for the same error rates over asymmetric channels, the asymmetric codes can give higher data rates. Let us demonstrate these benefits of asymmetric quantum codes by means of some simple examples. In order to be fair, we will compare codes of similar decoding complexity.

In the simulations, we make a simplifying assumption about the channel model which was first used in MacKay *et al*. (2004) to simplify the simulation of quantum LDPC codes. We assume that the overall probability of error in the channel is given by *p*, while the individual probabilities of *X*, *Y* and *Z* errors are *p*_{x}=*p*/(*A*+2), *p*_{y}=*p*/(*A*+2) and *p*_{z}=*pA*/(*A*+2), respectively. The exact performance would require us to simulate a 4-ary channel and also account for the fact that some errors can be estimated modulo the stabilizer. However, we observed that if we ignored the effect of the stabilizer it does not change the error rates because these codes are non-degenerate. The 4-ary channel can be modelled as two binary symmetric channels (BSCs) one modelling the bit-flip channel and the other the phase-flip channel. For exact performance, these two channels should be dependent; however, a good approximation is to model the channel as two independent BSCs with crossover probabilities *p*_{x}+*p*_{y}=2*p*/(*A*+2) and *p*_{y}+*p*_{z}=*p*(*A*+1)/(*A*+2). In this case, the overall error rate in the quantum channel is the sum of the error rates in the two BSCs. While this approach is going to slightly overestimate the error rates, nonetheless it is useful and commonly used in literature. Since the *X*-channel uses a BCH code and decoded using a bounded distance decoder, we can just compute the *X*-error rate, in closed form as(5.1)The error rate in the *Z*-channel, , is obtained through simulations. The overall error rate is

The highest distance possible for a (symmetric) [[15, 1]] code is 5. However, should we use an asymmetric [[15, 1]] code, then we can get an [[15, 1, 3/7]] code. This code can be constructed by choosing and in lemma 3.1, both of length 15. We now consider the performance of quantum codes over a quantum channel of the formwhere *p*=*p*_{x}+*p*_{y}+*p*_{z}; *p*_{x}=*p*_{y}=*p*_{z}/*A*. As we vary the channel asymmetry *A*=*p*_{z}/*p*_{x}=*p*_{z}/*p*_{y}, we keep the probability of error *p*=*p*_{x}+*p*_{y}+*p*_{z} constant. On a symmetric channel, the asymmetric code is going to fare worse than the symmetric code. If we increase the asymmetry of the channel then we can see that the code performance improves. Figure 1 shows the performance of [[15, 1, 3/7]] code over various asymmetric channels.

While it is not shown here, the performance of the symmetric code does not change too much as the channel asymmetry is varied. The key observation is that increasing channel asymmetry improves the performance of the asymmetric code. Figure 2 compares the performance of the symmetric and asymmetric codes. For clarity, the asymmetric code's performance is shown over three values of channel asymmetry, while the symmetric code's performance is shown only when the channel asymmetry is 100, since this is the point of interest for us.

Let us now compare the performance of a [[31, 1, 7]] quantum BCH code with its asymmetric counterpart. There exists a [[31, 11, 3/7]] quantum BCH code. In figure 3, we see that over a channel with asymmetry *A*=100, the performance of the asymmetric code is comparable to that of the symmetric code, but we are able to operate at a rate 10 times larger.

### (a) Decoding LDPC codes

The LDPC codes were decoded using an algorithm similar to the hard decision bit-flipping algorithm given by Kou *et al*. (2001). This is an instance of the bit-flipping algorithm originally given by Gallager. The maximum number of iterations for decoding is set to 50. A small modification had to be made to accommodate the special situation of quantum syndrome decoding. By measuring the generators of the stabilizer group, we obtain a classical syndrome, which, due to the fact that only ±1 eigenspaces occur in all of the generators, is hard information. We use the syndrome as shown in figure 4 and initialize all the bit nodes with 0 at the start of the algorithm. Then the algorithm proceeds in the usual fashion as in Kou *et al*. (2001). We implemented this algorithm and ran several simulations, which are described next.

In figure 5, we see the performance of [[255, 159, 5/17]], given in table 3, as the channel asymmetry is varied from 1 to 100. As we observed with the BCH asymmetric codes in §5, here also we see that as we increase the asymmetry the code starts to perform better. As the asymmetry is increased, eventually the performance of the quantum code approaches the performance of the classical LDPC code.

Tolerating a little rate loss improves the performance as can be seen from figure 6, especially at low channel asymmetries. If we increase the distance of the BCH code, the code becomes more tolerant to variations in channel asymmetry as can be seen by the performance of [[255, 143, 9/17]] in figure 7. This plot also illustrates an important point. Our channel model assumes that as we vary the channel asymmetry we keep the total probability of error in the channel fixed. This implies that while the probability of *X*-errors goes down, the probability of *Z*-errors tends to *p*, the total probability of error. Hence, the reduction in error rate in the *X*-channel must more than compensate for the increase in *Z*-error rate. If on the other hand, we had fixed the probability of error in the *Z*-channel and varied the channel asymmetry then we would observe a monotonic improvement in the error rate because on one hand the *Z*-error rate does not change but the *X*-error rate does.

Comparing with the short length codes of §5 we see that the error rate falls much more sharply. Larger length codes can potentially give better error rates. The performance of a code with length 1023 is shown in figure 8.

## 6. Conclusion and discussion

We have presented several new results regarding asymmetric quantum error-correcting codes, namely linear programming bounds on the feasible parameters, constructions based on nested families of classical codes and a CSS construction based on LDPC/BCH pairs. Furthermore, we have emphasized that for the simulation of these codes a slight modification of the standard classical belief propagation type simulation is necessary. We have carried out performance simulations for some asymmetric quantum LDPC codes and found that as expected the performance is a function of the channel asymmetry.

The question naturally raises how the codes presented in this work, in particular those obtained by the LDPC/BCH construction presented in §4, compare with the codes proposed by Ioffe & Mézard (2007). Strictly speaking, both constructions have regimes where they can perform better than the other. But it appears that the algebraically constructed asymmetric codes have the following benefits with respect to the randomly constructed ones of Ioffe & Mézard (2007).

They give comparable performance and higher data rates with shorter lengths.

The benefits of classical algebraic LDPC codes are inherited as low error floors compared with the random LDPC codes.

The code construction is of lower complexity.

Our rationale for these benefits is as follows. Please note that the method of Ioffe & Mézard (2007) relies on random LDPC codes. The claim that we require short lengths follows from the fact that the algebraic constructions (considered in this paper) are better than random LDPC codes with respect to finite-length effects such as error floors. Since the quantum codes inherit the properties of the associated classical codes, we expect the codes proposed here to fare better than those of Ioffe & Mézard (2007) in this regard. This is in addition to the empirical observations that we construct codes at lengths of 256 with rates of approximately 1/2 and performance comparable with those of Ioffe & Mézard (2007), whose lengths are 1024 or greater. The construction of Ioffe & Mézard (2007) is not systematic in the sense it relies on a random choice of the code words of the BCH to construct the LDPC code. The construction is also more complex and it is not clear if the method actually terminates with a good LDPC code with high probability. By contrast, for the codes proposed in this paper, the design parameters completely determine the structure of the LDPC code and the associated asymmetric quantum code.

Our codes also offer flexibility in the rate and performance of the code because we can choose many possible BCH codes for a given finite geometry LDPC code or vice versa. The flip side, however, is that the codes given here have a slightly higher complexity of decoding.

Open problems are to study the performance of alternatives to the hard decision bit algorithm used in the performance simulations. Alternatives would be to study other ways of message passing such as weighted bit flipping, belief propagation, etc.

Finally, it will be imperative to study whether the codes constructed in this paper can be used to perform universal fault-tolerant quantum computing on them without changing the bias in the error model.

## Acknowledgments

The authors would like to thank Marcus Silva for many useful discussions and for proposing the combined amplitude damping and dephasing channel, which is our main motivating example. We would also like to thank the referees for their detailed comments on the paper and for bringing to our attention relevant work by Knill *et al*. (1996) and Steane (1996). One of us (P.K.S.) would like to acknowledge the hospitality of NEC Laboratories America, Inc., wherein part of this research was conducted. This research was also supported by NSF CAREER award 0347310 and NSF grant CCF 0622201.

## Footnotes

↵Actually, this relation holds for

*δ*≤2^{⌈m/2⌉}+3. But this suffices for our purposes.- Received October 29, 2008.
- Accepted January 30, 2009.

- © 2009 The Royal Society