# Exact Performance of Concatenated Quantum Codes

###### Abstract

When a logical qubit is protected using a quantum error-correcting code, the net effect of coding, decoherence (a physical channel acting on qubits in the codeword) and recovery can be represented exactly by an effective channel acting directly on the logical qubit. In this paper we describe a procedure for deriving the map between physical and effective channels that results from a given coding and recovery procedure. We show that the map for a concatenation of codes is given by the composition of the maps for the constituent codes. This perspective leads to an efficient means for calculating the exact performance of quantum codes with arbitrary levels of concatenation. We present explicit results for single-bit Pauli channels. For certain codes under the symmetric depolarizing channel, we use the coding maps to compute exact threshold error probabilities for achievability of perfect fidelity in the infinite concatenation limit.

###### pacs:

03.67.-a, 03.65.Yz, 03.67.Hk## I Introduction

The methods of quantum error correction Shor (1995); Steane (1996); Nielsen and Chuang (2000) have, in principle, provided a means for suppressing destructive decoherence in quantum computer memories and quantum communication channels. In practice, however, a finite-sized error-correcting code can only protect against a subset of possible errors; one expects that protected information will still degrade, albeit to a lesser degree. The problem of characterizing a quantum code’s performance could thus be phrased as follows: what are the effective noise dynamics of the encoded information that result from the physical noise dynamics in the computing or communication device?

One could address this question by direct simulation of the quantum dynamics and coding procedure. However, for codes of non-trivial size, this approach rapidly becomes intractable. For example, in studies of fault-tolerance Preskill (1997) one often considers families of concatenated codes Knill and Laflamme (1996); Nielsen and Chuang (2000). An -qubit code concatenated with itself times yields an -qubit code, providing better error resistance with increasing . For even modest values of and , simulation of the resulting -dimensional Hilbert space requires massive computational resources; using simulation to find the asymptotic performance as (as required for fault-tolerant applications) is simply not on option.

Instead, a quantum code is often characterized by the set of discrete errors that it can perfectly correct Knill and Laflamme (1997). For example, the Shor nine-bit code Shor (1995) was designed to perfectly correct arbitrary decoherence acting on a single bit in the nine-bit register. Typical analyses of such codes implicitly assume that the physical dynamics can be described by single-bit errors occurring at some probabilistic rate; if this rate is small (e.g. for ), the probability that these errors will accumulate into a multi-bit uncorrectable error is also small (e.g. ). This type of leading-order analysis is limited to a weak-noise regime, and to error models strongly resembling the errors against which the code protects. Outside of this regime, these approximation methods fail to accurately describe the evolution of the encoded information.

In this work we take a different approach to characterizing error-correcting codes, which leads to a simple, exact analysis for arbitrary error models. As suggested above, a code transforms the physical dynamics of the device into the effective dynamics of the encoded information. In section II we derive this transformation for arbitrary noise, and present a compact method for its calculation.

In the case of identical, uncorrelated noise on individual qubits, this notion becomes particularly natural: encoding a logical qubit in several physical qubits yields an evolution less noisy than if the logical qubit had been stored, unencoded, in a single physical qubit. Thus a code acts a map on the space of qubit dynamics, mapping the dynamics of a single physical qubit to the dynamics of the encoded logical qubit. In section III we show how to calculate this map, and in section IV we use these maps to dramatically simplify the calculation of effective dynamics for concatenated codes when the physical dynamics do not couple code blocks.

In section V, we restrict our attention to uncorrelated single-bit Pauli errors, and in section VI we calculate the exact performance of several codes of interest under these error models. Finally, in section VII we use the coding maps to calculate the performance of certain concatenated codes, and find the exact threshold error probability for perfect fidelity in the infinite concatenation limit. These thresholds serve as important figures of merit for concatenation schemes, and for the codes considered here we find that the traditional approximate methods underestimate these thresholds by up to . Section VIII concludes, suggesting potential future applications for these techniques.

## Ii Describing Code Performance with Effective Channels

In this section we first describe error-correcting codes using a language that will facilitate the subsequent development. We will then present our method for exactly describing the effective dynamics of the encoded information. Though for clarity we restrict our discussion to codes storing a single qubit (sometimes called codes) all of the presented methods generalize naturally to codes storing quantum information of arbitrary dimension.

As an important preliminary, it can be argued Nielsen and Chuang (2000); Kraus (1983) that all physically possible transformations taking quantum states on a Hilbert space to states on a Hilbert space may be written in the following form:

(1) |

where the are linear operators from to and denotes the identity operator on . Such transformations are called quantum operations or channels, and are necessarily linear, trace-preserving, and completely positive. It is easy to see that the composition of quantum operations is also a quantum operation. (One also sees definitions requiring only , corresponding to the weaker requirement that a quantum operation be trace non-increasing rather than trace-preserving. However, the requirement of trace-preservation is better suited to our purposes here. See Nielsen and Chuang (2000) for a discussion of the distinction.)

### ii.1 The Error-Correction Process

The error-correction process, consisting of encoding, noise, and decoding, is depicted in Figure 1; we consider each stage in turn. An -qubit code uses a register of qubits to encode a single logical qubit by preparing the register in the state , where and are orthogonal states in the -dimensional Hilbert space of the register. The codespace (i.e., the space of initial register states) is spanned by these two states. In what follows it will be convenient to describe states by density matrices: let the logical qubit be given by and the initial register state by . Writing , the encoding operation is given by

(2) |

As , is a quantum operation.

After the encoding, the register state evolves due to some noise dynamics. In the setting of a quantum computer memory, the dynamics are continuous in time; assuming evolution for a time , we have with a quantum operation depending continuously on . (For master equation evolution , we have .) We will often omit the subscript and simply write . In the setting of a quantum communication channel, the noise process is usually given by the discrete application of a quantum operation ; thus if the transmitted state is , the received state is , which we write as for consistency.

After the noise process, an attempt is made to recover the initial register state from the current register state by applying a quantum operation , which may be written as

(3) |

As the initial state is known to be in the codespace, it is clearly more beneficial to return the state to the codespace than to do otherwise: lacking any other information, one could at least prepare the completely mixed state in the codespace , yielding an average fidelity of , rather than leaving the register outside the codespace, yielding a fidelity of 0. We will therefore restrict our attention to error-correction processes that take all register states back to the codespace. (I.e., we assume no leakage errors during recovery.)

With the above assumption, the post-recovery state has support entirely on the codespace; thus it can be described by its restriction to the codespace, the logical single-qubit state such that . Call the decoding operation (shown to be a quantum operation in Lemma 1 of Appendix B):

(4) |

With this definition, . We will consider the logical state as the outcome of the error-correction process, and therefore may say that the code is given by its encoding and decoding operations, i.e. .

To build intuition for the decoding operation , we note that for most codes considered in the literature (and all of the specific codes considered later in this paper) the recovery procedure is given in a particular form. First, a syndrome measurement is made, projecting the register state onto one of orthogonal two-dimensional subspaces; let the measurement be specified by projectors . After the measurement (whose outcome is given by , the index of the corresponding projector), the recovery operator acts on the register, unitarily mapping the subspace projected by back to the codespace. For such codes, the recovery superoperator is given by (3) with , and is the expected state that results from averaging over syndrome measurement outcomes.

For codes of this form, let denote the orthonormal basis for the syndrome space projected by such that and . Then , and using the expression for given in (4) yields

(5) |

Thus is the sum of the single-qubit density matrices that result from restricting to each of the syndrome spaces, with basis determined by the recovery operator.

As an example, consider the bitflip code Nielsen and Chuang (2000), a three-qubit code that protects against single bitflip errors. The bitflip code’s encoding transformation is given by

(6) |

After the action of some error dynamics, the syndrome measurement then projects the register state into one of four subspaces: the codespace itself, and the three subspaces that result from flipping the first, second, or third bit of states in the codespace. The corresponding recovery operator simply flips the appropriate bit back, attempting to reverse the error. Thus the basis specifying the decoding operation is given by

(7) |

We will use the bitflip code as an example throughout this work.

### ii.2 Calculating the Effective Dynamics

The transformation gives the effective dynamics of the encoded information resulting from the physical dynamics . Let be the map giving these effective dynamics: . From the above discussion, the effective dynamics are simply the result of encoding, followed by noise, followed by decoding, i.e.

(8) |

As is the composition of quantum operations , and , it is itself a quantum operation. We may therefore call the effective channel describing the code and physical noise dynamics .

Because the effective channel is only a map on single qubit states, it should have a compact description — in particular, a description much more compact than some arbitrary noise acting on -qubit states. By calculating such a compact description, we may easily find the effective evolution of an arbitrary initial state without explicitly considering the physical noise dynamics. As we now show, may be written as a matrix with a simple interpretation. (See Ruskai et al. (2001) for a full discussion of qubit channels represented in this fashion.)

For each Pauli matrix , let . The Pauli matrices form a basis for qubit density matrices, and so the initial logical qubit may linearly parameterized by its expectation values as follows:

(9) |

(As the trace of a density matrix must be 1 we will always have , but it will be convenient to include this term.) Similarly, the final logical qubit may be linearly parameterized by its expectation values . Thus the effective channel may be written as the mapping from the expectation values of to the expectation values of . Writing and , the linearity of allows it to be written as the matrix such that . The fidelity of a pure logical qubit through the effective channel is then given by we need only find the entries of its matrix representation. (More generally, if the code stored a -dimensional state rather than the two-dimensional state of a qubit, the logical density matrices and would be expanded in the basis of the identity matrix and the generators of , and would be represented as a matrix.) . Thus to fully characterize the effective channel

To find these matrix elements, we consider the encoding and decoding processes in more detail. Letting denote , the encoding transformation acts on (given by (9)) to prepare the initial register state

(10) |

Thus the encoding operation is completely characterized by the operators, which are easily constructed from the codewords:

(11) |

As expected, is the state on the codespace, and vanishes elsewhere.

Now consider the decoding process, which yields the logical state . We may express the expectation values in terms of , the register state prior to recovery, as follows:

(12) |

Exploiting the cyclic property of the trace and noting that , we have

(13) |

Thus the decoding operation is completely characterized by the operators.

Substituting into (13), we have . Substituting in the expression for given by (10) then yields

(14) |

Letting the matrix elements of be given by

(15) |

for , we have , i.e. .

To completely characterize the effective channel , then, we need only compute these matrix elements. In fact, trace-preservation (i.e. requires and . Thus the effect on the logical information of the potentially complex dynamics of the -qubit register space are characterized by the remaining twelve matrix elements of . If is time-dependent, then the only observable effects of this time-dependence will appear in the time dependence of the , and gives the effective channel for correction performed at time . Note that the dynamics need not be related to those against which the code was designed to protect.

We have thus shown that the effective dynamics may be calculated by evaluating (15), which requires constructing the and operators. The operators are easily understood to be the operators which act as on the codespace and vanish elsewhere; to build intuition for the operators, consider codes whose recovery is specified by syndrome measurement projectors and recovery operators as discussed in section II.1. For these codes, we have , and so . This expression may be simplified by noting that maps the codespace to itself and vanishes elsewhere, and unitarily maps the space projected by to the codespace. Thus unitarily maps the space projected by to itself and vanishes elsewhere, i.e. . We therefore have

(16) |

Using the expressions for given in (11) and , we have

(17) |

Thus we see that in this case is simply the sum of the operators acting on each of the syndrome spaces, with -eigenstates and determined by the recovery procedure. Note that is the identity operator on the entire register space.

## Iii Coding as a Map on Channels

One often considers noise models consisting of uncorrelated noise on each of the physical qubits. This type of model arises naturally in a communication setting, where the register qubits are sent over a noisy transmission line one at a time, and is also appropriate for various physical implementations of a quantum computer. (By contrast, one can also consider error models in which correlated noise dominates Lidar et al. (2001).) For such models, we may write

(18) |

where is a quantum operation on a single qubit.

The goal of encoding a qubit is to suppress decoherence: multiple qubits are employed to yield an effective channel , which should be less noisy than the channel resulting from storing information in a single physical qubit, namely . A code can thus be seen as a map on channels, taking to . More precisely, for an -qubit code , define the corresponding coding map by

(19) |

We now derive an expression for the coding map of an arbitrary code . In section II.2 we described how may be specified by its matrix elements , given by (15). Since is a single-qubit quantum operation, it may also be written as a matrix such that if takes to , then . We seek an expression for the matrix elements of the effective channel in terms of the matrix elements of the physical channel .

Operators on qubits may be written as sums of tensor products of Pauli matrices; we may therefore write the and operators describing as

(20) | |||||

(21) |

E.g., for the bitflip code described in section II.1 by (6) and (7), we may calculate the and operators using (11) and (17); expanding the results in the basis of Pauli operators yields

(22) |

and

(23) |

To find the matrix elements of the effective channel, we substitute (18), (20), and (21) into the expression for these matrix elements given by (15). Noting that and yields

(24) |

From the orthogonality of Pauli matrices, the matrix , when written as a vector of expectation values, has a 1 in the component and zeros elsewhere. Further, is simply the component of . Thus , and we have

(25) |

Thus the matrix elements of can be expressed as polynomials of the matrix elements of , with the polynomial coefficients depending only on the and of the code. These polynomials specify . By computing these polynomials for a code , one can easily calculate the effective channel for the code due to any error model with identical, uncorrelated noise acting on each physical qubit. (If a different noise model acts on each physical qubit, i.e. , simply replace with in (25).)

## Iv Concatenated Codes

We now consider concatenated codes Nielsen and Chuang (2000); Knill and Laflamme (1996). We first describe the procedure for constructing such codes, and then show how the coding maps make the calculation of the effective channels for such codes straightforward.

### iv.1 Constructing Concatenated Codes

We now describe how two codes may be concatenated to form a larger code; the procedure is depicted in Figure 2. Let the two codes be an -qubit code , called the outer code, and an -qubit code , called the inner code. A logical qubit is encoded first using the outer code , yielding the -qubit state . Each of these qubits is then encoded by the inner code; i.e., the map acts on . The composition of these encodings forms the encoding map for the concatenated code:

(26) |

The sections of the register encoding each of the qubits in are called blocks; each block contains qubits. After the encoding, a noise process acts on the entire -qubit register.

A simple error-correction scheme (and one that seems reasonable for use in a scalable architecture) coherently corrects each of the code blocks based on the inner code, and then corrects the entire register based on the outer code. I.e., the decoding map for the concatenated code is given by

(27) |

We denote the concatenated code (with this correction scheme) by ; note that is an -qubit code.

### iv.2 Effective Channels for Concatenated Codes

Suppose that we have computed the effective channel due to a code with some noise dynamics , and wish to consider the effective channel resulting from the concatenated code . We assume that each -bit block in the register evolves according to the noise dynamics and no cross-block correlations are introduced, i.e. that the evolution operator on the -bit register is

(28) |

By definition, we have = . Substituting (26), (27) and (28) into this expression yields

(29) |

where we have used . This result makes sense: each of the blocks of bits represents a single logical qubit encoded in , and as the block has dynamics , this logical qubit’s evolution will be described by . Comparing with the definition of the coding map (19), we then have

(30) |

Thus given the effective channel for a code and an error model, the coding map makes it straightforward to compute the effective channel due to the concatenated code .

Further, suppose that the original noise model had the form of uncorrelated noise on single physical qubits, as given by (18). Then , and so . We may therefore conclude that composing coding maps gives the coding map for the concatenated code, i.e.

(31) |

More generally, we may characterize both the finite and asymptotic behavior of any concatenation scheme involving the codes by computing the maps . Then the finite concatenation scheme is characterized by . We expect the typical to be sufficiently well-behaved that standard dynamical systems methods Devaney (1989) will yield the limit of ; one need not compose the explicitly. In section VII, we will consider such asymptotic limits in more detail.

## V Diagonal Channels

As an application of the methods presented above, we will consider the commonly-considered error model in which each physical register qubit is subjected to the symmetric depolarizing channel Nielsen and Chuang (2000). These single-qubit noise dynamics are given by the master equation

(32) |

where for any linear qubit operator the Lindblad decoherence operator is given by

(33) |

and is a measure of the noise strength. This master equation is easily solved, yielding a qubit channel with matrix representation

(34) |

Before calculating effective channels due to this error model, it will be useful to discuss the more general set of channels whose matrix representation is diagonal. As we will see, these channels correspond to single-bit Pauli channels, and will allow us to demonstrate the power of the techniques developed above.

Consider a qubit channel given by a diagonal matrix . From trace preservation , so let the channel with , and be denoted for compactness. (Thus the depolarizing channel (34) is given by .) In King and Ruskai (2001) it is shown that complete positivity of such a channel requires

(35) |

Now consider the single-bit Pauli channel in which the transmitted state is subjected to the Pauli operators , , and with exclusive probabilities , , and , i.e.

(36) | |||||

It is easy to show that this channel has the diagonal matrix representation

(37) |

and so any Pauli channel is a diagonal channel. The converse is also true: choosing , , and yields the channel , and the complete positivity constraints (35) yield the standard probability rules and . Thus any diagonal channel may be realized as a Pauli channel. Pauli channels are among the most commonly considered error models in the literature, and we will restrict our attention to diagonal channels for the remainder of this work.

The effect of a diagonal channel on a qubit is simple to interpret: we have , , and . Thus the , , and components of decay independently, and we may therefore speak of the decoherence of , , and . Recalling from section II.2 that the fidelity of a pure state through a qubit channel is given by , the respective fidelities of -, -, and -eigenstates through the channel are , , and . More generally, the fidelity of a pure state (requiring ) is given by . A common figure of merit for a channel is the worst-case fidelity of a pure state, which for a diagonal channel is . Thus if for a given error model a code yields an effective channel and a code yields an effective channel , we say that outperforms if .

Many commonly considered codes are stabilizer codes Nielsen and Chuang (2000); Gottesman (1997), which are designed to detect and correct Pauli errors; it would therefore not be so surprising if the coding maps for such codes were particularly well-behaved when acting on a Pauli channel. In fact, as proved in Appendix A, if is a stabilizer code and is diagonal, then is also diagonal. Thus just as arbitrary codes act as maps on the space of qubit channels, stabilizer codes act as maps on the space of diagonal qubit channels.

## Vi Exact Performance for Several Codes of Interest

We will now present the effective channels for several codes of interest under diagonal error models. The codes considered here may all be formulated as stabilizer codes; thus, as described in the previous section, the effective channels will also be diagonal. The diagonal elements of the effective channel may be calculated either using the coding map methods presented in section III, or using the stabilizer formalism as shown in Appendix A, which may be computationally advantageous. For each code, we will compute the effective channel for a general diagonal error model , and then interpret the results for the symmetric depolarizing channel .

The bitflip code first mentioned in section II.1 is a stabilizer code; letting denote the corresponding coding map, we find

(38) |

As the bitflip code is only a three-qubit code, it is not unreasonable to check this result with more conventional methods, e.g. by counting bitflip and phaseflip errors, or by working in the Heisenberg picture to compute the evolution of the relevant expectation values. However, for larger codes such computations will rapidly become unmanageable.

To examine the bitflip code acting under the symmetric depolarizing channel, define ; the functions , , and are plotted in Figure 3 along with (describing the decoherence of the physical qubits) for comparison. We see that , and thus the decoherence of is suppressed by the bitflip code. However, , and thus the decoherences of and are increased by the bitflip code.

More generally, for any we have , so for any physical channel in this regime the bitflip code always suppresses decoherence of and increases decoherence of . Decoherence of is suppressed when and , and increased for all other positive values of and . We may therefore conclude that under a general Pauli channel the bitflip code increases the fidelity of some transmitted states at the expense of others, and thus the bitflip code is outperformed by storing the logical qubit in a single physical bit. and

However, as the bitflip code is designed to only protect against physical bitflip () errors, it should not be expected to perform well in the presence of arbitrary Pauli errors. If we consider physical channels with only errors, we find that the bitflip code suppresses decoherence of all encoded states. More precisely, suppose that the physical qubits are evolving via a Pauli channel (36) with only errors, i.e. . Then , and

Now consider the three-qubit phaseflip code Nielsen and Chuang (2000), with encoding for . This code is completely analogous to the bitflip code, detecting and correcting single phaseflip () errors instead of single bitflip () errors. The phaseflip code’s coding map is exactly the same as that of the bitflip code, with the role of and interchanged:

(39) |

The concatenation phaseflip(bitflip) yields the Shor nine-bit code Shor (1995); Nielsen and Chuang (2000) with encoding . Thus . Evaluating this composition using the coding maps (38) and (39),

(40) | |||||

where

(41) |

(The combinatoric analysis required to reproduce this result by counting bitflip and phaseflip errors would be quite tedious!)

To examine the Shor code acting on the symmetric depolarizing channel, let ; the functions , and are plotted in Figure 4. We see that for short times (or equivalently, weak noise-strength ), the Shor code suppresses decoherence of , , and . For long times, however, the code increases the decoherence of all three expectation values, and as , in an intermediate regime the code suppresses the decoherence of some of the expectation values while increasing that of others. Thus to suppress the decoherence of an arbitrary logical state, correction needs to be performed at a time when .

Above we defined the phaseflip code by the encoding ; we could have also used the encoding given by , . Call the code with this encoding phaseflip, with coding map . As this modification of the phaseflip code simply interchanges the encoded - and -eigenstates, the new effective channel is simply that of the original phaseflip code with the effects of the channel on the and components of interchanged:

(42) |

with the polynomials , and defined by (41). Comparing to (40), we see that again this modification of the Shor code simply interchanges the effect of the channel on and