Quantum error correction for beginners

The fundamental unit of quantum information is the qubit. Unlike the classical bit, the qubit can exist in coherent superpositions of its two states, denoted as |0〉 and |1〉. These basis states can be, for example, photonic polarization, atomic spin states, electronic states of an ion or charge states of superconducting systems. An arbitrary state of an individual qubit, |φ〉, can be expressed as

$$\begin{equation} {\left\vert{\phi}\right\rangle} = \alpha{\left\vert{0}\right\rangle} + \beta{\left\vert{1}\right\rangle}, \end{equation} \tag{ 1 }$$

where |0〉 and |1〉 are the two orthonormal basis states of the qubit and |α|² + |β|² = 1. Quantum gate operations are represented by unitary operations acting on the Hilbert space of a collection of qubits. Unlike classical information processing, conservation of probability for quantum states requires that all operations be reversible and hence unitary.

When describing a quantum gate on an individual qubit, any dynamical operation, G, is a member of the unitary group U(2), which consists of all 2 × 2 matrices where G^† = G⁻¹. Up to a global (and unphysical) phase factor, any single qubit operation can be expressed as a linear combination of the generators of SU(2) as,

$$\begin{equation} G = c_I \sigma_I + c_x \sigma_x + c_y\sigma_y + c_z\sigma_z, \end{equation} \tag{ 2 }$$

where

$$\begin{eqnarray} \fl \sigma_x = \left(\begin{array}{@{}ll@{}} 0 & 1 \\ 1 & 0 \end{array}\right), \quad \sigma_y = \left(\begin{array}{@{}ll@{}} 0 & -i \\ i & 0 \end{array}\right), \quad \sigma_z = \left(\begin{array}{@{}ll@{}} 1 & 0 \\ 0 & -1 \end{array}\right),\nonumber\\ \end{eqnarray} \tag{ 3 }$$

are the Pauli matrices, σ_I is the 2 × 2 identity matrix, c_I is a real number, and (c_x, c_y, c_z) are complex numbers satisfying,

$$\begin{eqnarray} &&|c_I|^2+|c_x|^2+|c_y|^2+|c_z|^2 = 1, \\ &&\Re(c_Ic_x^*)+\Im(c_yc_z^*) = 0, \\ &&\Re(c_Ic_y^*)+\Im(c_xc_z^*) = 0, \\ &&\Re(c_Ic_z^*)+\Im(c_xc_y^*) = 0. \end{eqnarray} \tag{ 4 }$$

Here ℜ and ℑ are the real and imaginary components, respectively.

Although the field of QEC is largely based on classical coding theory, there are several issues that need to be considered when transferring classical error correction techniques to the quantum regime.

First, coding based on data-copying, which is extensively used in classical error correction, cannot be used due to the no-cloning theorem of quantum mechanics [WZ82]. This result implies that there exists no transformation resulting in the following mapping,

$$\begin{equation} U({\left\vert{\phi}\right\rangle} \otimes {\left\vert{\psi}\right\rangle}) = {\left\vert{\phi}\right\rangle} \otimes {\left\vert{\phi}\right\rangle} \tqs \forall {\left\vert{\phi}\right\rangle}, \end{equation} \tag{ 5 }$$

i.e. it is impossible to perfectly copy an unknown quantum state. This means that quantum data cannot be protected from errors by simply making multiple copies. Secondly, direct measurement cannot be used to effectively protect against errors, since this will act to destroy any quantum superposition that is being used for computation. Error correction protocols must therefore be employed, which can detect and correct errors without determining any information regarding the qubit state. Unlike classical information, qubits are susceptible to both traditional bit errors |0〉 ↔ |1〉, and also phase errors |0〉 ↔ |0〉, |1〉 ↔ −|1〉. Hence any error correction procedure needs to be able to simultaneously correct for both. Finally, errors in quantum information are intrinsically continuous (i.e. qubits do not experience full bit or phase flips but rather an angular shift of the qubit state by any angle). This issue will be discussed in more depth in section 9.

At its most basic level, QEC utilizes the idea of redundant encoding. This is where the total size of the Hilbert space is expanded beyond what is needed to store a single qubit of information. This way, errors on individual qubits are mapped to a large set of mutually orthogonal subspaces, the size of which is determined by the number of qubits utilized in the code. Finally, the error correction protocol cannot allow us to gain information regarding the coefficients, α and β of the encoded state, as doing so would collapse the system.

The first possible source of error is coherent, systematic control errors. This type of error is typically associated with incorrect knowledge of the system dynamics. Namely, otherwise perfect control assuming a system governed by a Hamiltonian H' when the actual system dynamics is governed by H. As qubit systems must be characterized prior to being used [PCZ97, CSG⁺05], finite experimental resolution with these processes will lead to coherent control errors. As these errors are coherent inaccuracies applied to the qubit, they can be mitigated using coherent techniques such as composite pulse sequences [LF79, Lev86, BHC04, Jon09]. Other control errors (e.g. arising from fluctuations in control fields) are not coherent processes and are dealt with in a similar way to environmental coupling described further on.

As this source of error is coherent and systematic it causes one to apply the same, undesired gate operation and can be analysed without moving to the density matrix formalism. With respect to the first of our algorithms, we are able to model this in several different ways. To keep things simple, we assume that incorrect characterization of the control dynamics leads to a gate which is not σ_I, but instead introduces a small rotation around the X-axis of the Bloch sphere. This results in the state,

$$\begin{equation} {\left\vert{\psi}\right\rangle}_{{\rm final}} = \prod^N \rme^{\rmi\epsilon \sigma_x}{\left\vert{0}\right\rangle} = \cos(N\epsilon){\left\vert{0}\right\rangle} + \rmi\sin(N\epsilon){\left\vert{1}\right\rangle}. \end{equation} \tag{ 8 }$$

We now measure the system in the |0〉, |1〉 basis. Due to these errors, the probability of measuring the system in the |0〉 or |1〉 state is,

$$\begin{eqnarray} &&P({\left\vert{0}\right\rangle}) = \cos^2(N\epsilon) \approx 1- (N\epsilon)^2, \\ &&P({\left\vert{1}\right\rangle}) = \sin^2(N\epsilon) \approx (N\epsilon)^2. \end{eqnarray} \tag{ 9 }$$

Hence, the probability of error in this trivial quantum algorithm is given by p_error ≈ (N)², which will be small given that N ≪ 1. The systematic error in this system is quadratic in both the small systematic over rotation and the total number of applied identity operations. This is expected as this rotational error always acts in the same direction every time it is applied.

Environmental decoherence is another important source of errors in quantum systems. We will take a simple decoherence model and examine how our second algorithm behaves. Later in section 9 we will illustrate a more complicated decoherence model that arises from standard mechanisms.

Consider a very simple environment, which is another two level quantum system. This environment has two basis states, |e₀〉 and |e₁〉, that satisfy the completeness relations,

$$\begin{equation} {\left\langle{e_i}\right\vert}e_j\rangle = \delta_{ij}, \quad {\left\vert{e_0}\right\rangle}{\left\langle{e_0}\right\vert} + {\left\vert{e_1}\right\rangle}{\left\langle{e_1}\right\vert} = I. \end{equation} \tag{ 10 }$$

We will also assume that the environment couples to the qubit in a specific way. When the qubit is in the |1〉 state, the coupling flips the environmental state, while if the qubit is in the |0〉 state nothing happens to the environment. Finally, this model assumes the system/environment interaction only occurs during the wait stage of the algorithm (while the Identity gate is being applied). As with the first algorithm we should measure the state |0〉 with probability one. The reason for utilizing the second of our algorithms in this example is that this specific decoherence model acts to reduce coherence between the |0〉 and |1〉 states. Therefore, we require a coherent superposition to observe any effect from the environmental coupling. We assume the environment is initialized in the state, |E〉 = |e₀〉, and then coupled to the system,

$$\begin{equation} HI H{\left\vert{0}\right\rangle}{\left\vert{E}\right\rangle} = \case{1}{2}({\left\vert{0}\right\rangle}+{\left\vert{1}\right\rangle}){\left\vert{e_0}\right\rangle} + \case{1}{2}({\left\vert{0}\right\rangle}-{\left\vert{1}\right\rangle}){\left\vert{e_1}\right\rangle}. \end{equation} \tag{ 11 }$$

As we are considering environmental decoherence, pure states will be transformed into classical mixtures, hence we now move into the density matrix representation for the state HIH|0〉|E〉,

$$\begin{eqnarray} \fl\rho_{f}& = \case{1}{4}( {\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} + {\left\vert{0}\right\rangle}{\left\langle{1}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{0}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}){\left\vert{e_0}\right\rangle}{\left\langle{e_0}\right\vert}\nonumber\\ \fl&\quad +\,\case{1}{4}( {\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} - {\left\vert{0}\right\rangle}{\left\langle{1}\right\vert}-{\left\vert{1}\right\rangle}{\left\langle{0}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}){\left\vert{e_1}\right\rangle}{\left\langle{e_1}\right\vert} \nonumber\\ \fl&\quad +\, \case{1}{4}( {\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} - {\left\vert{0}\right\rangle}{\left\langle{1}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{0}\right\vert}-{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}){\left\vert{e_0}\right\rangle}{\left\langle{e_1}\right\vert}\nonumber\\ \fl&\quad +\,\case{1}{4}( {\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} + {\left\vert{0}\right\rangle}{\left\langle{1}\right\vert}-{\left\vert{1}\right\rangle}{\left\langle{0}\right\vert}-{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}){\left\vert{e_1}\right\rangle}{\left\langle{e_0}\right\vert}. \end{eqnarray} \tag{ 12 }$$

As we have no access to the environmental degrees of freedom, we trace over this part of the system, giving,

$$\begin{eqnarray} \fl{\rm Tr}_{E}(\rho_f) &= \case{1}{4}( {\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} + {\left\vert{0}\right\rangle}{\left\langle{1}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{0}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert})\nonumber\\ \fl&\quad +\,\case{1}{4}( {\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} - {\left\vert{0}\right\rangle}{\left\langle{1}\right\vert}-{\left\vert{1}\right\rangle}{\left\langle{0}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}) \nonumber\\ \fl&= \case{1}{2}({\left\vert{0}\right\rangle}{\left\langle{0}\right\vert}+{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}). \end{eqnarray} \tag{ 13 }$$

Measurement of the system will consequently return |0〉 50% of the time and |1〉 50% of the time. This final state is a complete mixture of the two qubit states and is consequently a classical system. The coupling to the environment removed all the coherences between the |0〉 and |1〉 states and the second Hadamard transform, intended to rotate $({\left\vert{0}\right\rangle}+{\left\vert{1}\right\rangle})/\sqrt{2} \rightarrow {\left\vert{0}\right\rangle}$, has no effect on the qubit state.

As we assumed that the system/environment coupling during the wait stage causes the environmental degree of freedom to 'flip' (when the qubit is in the |1〉 state) this decoherence model implicitly incorporates a temporal effect. The temporal interval of the identity gate in the above algorithm is long enough to enact the controlled-flip operation. If we assumed a controlled rotation that was not a full flip on the environment, the final mixture would not be 50/50. Instead there would be a residual coherence between the qubit states and an increased probability of our algorithm returning a |0〉. Section 9 revisits the decoherence model and illustrates how time-dependence is explicitly incorporated.

Other sources of error such as qubit initialization, measurement errors, qubit loss and qubit leakage can be modelled in a very similar manner. As with coherent control errors and environmental decoherence, the specifics of other error channels can be modelled in a coherent or incoherent manner, depending on the physical mechanisms. The examples shown below are commonplace within QEC analysis and adequately apply to a large number of systems.

Measurement errors can be modelled in the same way as environmental decoherence, acting incoherently on the system. Measurement errors can be described in two slightly different ways. The first is to use the following positive operator value measures (POVMs),

$$\begin{eqnarray} &&F_0 = (1-p_M){\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} + p_M{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}, \\ &&F_1 = (1-p_M){\left\vert{1}\right\rangle}{\left\langle{1}\right\vert} + p_M{\left\vert{0}\right\rangle}{\left\langle{0}\right\vert}, \end{eqnarray} \tag{ 14 }$$

where p_M is the probability of measurement error. These are not measurement projectors as $F_0^2 \neq F_0$ and $F_1^2 \neq F_1$. The second method is to apply the following mapping to the qubit,

$$\begin{equation} \rho \rightarrow \rho' = (1-p_M)\rho + p_M X\rho X \end{equation} \tag{ 15 }$$

followed by a perfect measurement in the (|0〉, |1〉) basis. These two models give exactly the same probabilities for each outcome. Defining A₀ = |0〉〈0| and A₁ = |1〉〈1| as the measurement projectors onto the (|0〉, |1〉) basis we find

$$\begin{eqnarray} &&{\rm Tr}(F_0\rho) = (1-p_M){\rm Tr}(A_0\rho) + p_M{\rm Tr}(A_1\rho), \\ &&{\rm Tr}(F_1\rho) = (1-p_M){\rm Tr}(A_1\rho) + p_M{\rm Tr}(A_0\rho), \end{eqnarray} \tag{ 16 }$$

$$\begin{eqnarray} \fl{\rm Tr}(A_0\rho') &= (1-p_M){\rm Tr}(A_0\rho) + p_M{\rm Tr}(XA_0X\rho) \nonumber\\ \fl&= (1-p_M){\rm Tr}(A_0\rho) + p_M{\rm Tr}(A_1\rho), \nonumber\\ \fl{\rm Tr}(A_1\rho') &= (1-p_M){\rm Tr}(A_1\rho) + p_M{\rm Tr}(XA_1X\rho) \nonumber\\ \fl&= (1-p_M){\rm Tr}(A_1\rho) + p_M{\rm Tr}(A_0\rho). \end{eqnarray} \tag{ 17 }$$

Hence, either method will result in the same probabilities for a given value of p_M. The difference between these two models is the state the measured qubit is projected to.

When using the POVMs in equation (14), the collapsed state of the qubit is given by

$$\begin{equation} \rho \rightarrow \frac{M_i\rho M_i^{\dagger}}{{\rm Tr}(F_i\rho)} \tqs i = 0,1, \end{equation} \tag{ 18 }$$

where

$$\begin{eqnarray} &&M_0 = \sqrt{1-p_M}{\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} + \sqrt{p_M}{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}, \\ &&M_1 = \sqrt{1-p_M}{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert} + \sqrt{p_M}{\left\vert{0}\right\rangle}{\left\langle{0}\right\vert}. \end{eqnarray} \tag{ 19 }$$

Therefore the resulting state, after measurement, will not be initialized in a known state. If the second model is used, then the system is initialized to either |0〉 or |1〉 depending on which projector is used. To see this explicitly, consider the state,

$$\begin{equation} \case{1}{\sqrt{2}}\left({\left\vert{0}\right\rangle} + {\left\vert{1}\right\rangle}\right). \end{equation} \tag{ 20 }$$

Using both models, the probability of measuring |0〉 is 1/2 (as the above state is invariant under a bit-flip error). If the POVM model is used (using the F₀ and M₀ operators), the state after measurement is,

$$\begin{equation} \sqrt{(1-p_m)}{\left\vert{0}\right\rangle} + \sqrt{p_m}{\left\vert{1}\right\rangle}. \end{equation} \tag{ 21 }$$

The collapsed state, after measurement, is a superposition of |0〉 and |1〉, with amplitudes related to p_m. If we use the second model (using the projector A₀), the state after measurement is simply |0〉. As measurement is generally followed by either discarding the qubit or reinitializing it in a known state, both models can generally be used interchangeably with no adverse consequences.

Qubit loss is modelled in a slightly different manner. When a qubit is lost, it is effectively removed from the system. This channel can be modelled by simply tracing out the lost qubit, Tr_i(ρ), where i is the index of the lost qubit. This reduces the dimensionality of the qubit space by a factor of two.

The loss of the physical object means that it cannot be directly measured or coupled to any other ancillary system. Even though this model of qubit loss (with regards to the information stored on the qubit) is equivalent to incoherent processes such as environmental coupling, correcting this type of error requires additional machinery on top of standard QEC protocols. Standard correction protocols can protect against the loss of information on a qubit, provided that the physical object still exists in the computer. Therefore, an initial non-demolition detection must be employed (which determines if the qubit is actually present without performing a projective measurement on the computational state) before standard correction can correct the error. Provided that these non-demolition protocols are employed, loss actually becomes a preferred channel in error correction. If a loss event is detected and the quit is replaced, this heralds the qubit experiencing the error. This additional information can be used within error correction protocols to increase performance.

Initialization of the qubit can be modelled either using a coherent systematic or incoherent process. If an incoherent model is employed, initialization can be modelled in essentially the same way as imperfect measurement. If we have a probability p_I of initialization error (where p_I encapsulates the internal mechanisms that introduce errors) and we initialize the qubit in the |0〉 state, the initial state of the system is given by the mixture,

$$\begin{equation} \rho_i = (1-p_I){\left\vert{0}\right\rangle}{\left\langle{0}\right\vert} + p_I{\left\vert{1}\right\rangle}{\left\langle{1}\right\vert}. \end{equation} \tag{ 22 }$$

In contrast, we could consider an initialization model which is achieved via a coherent unitary operation where the target is the desired initial state. In this case, the initial state is pure, but contains a non-zero amplitude of the undesired target, for example,

$$\begin{equation} {\left\vert{\psi}\right\rangle} = \alpha{\left\vert{0}\right\rangle} + \beta{\left\vert{1}\right\rangle}, \end{equation} \tag{ 23 }$$

where |α|² + |β|² = 1 and |β|² ≪ 1. The interpretation of these two types of initialization models is identical to the coherent and incoherent models presented. Again, the effect of these types of errors relates to the probabilities of measuring the system in an erred state.

One final type of error that we can briefly mention is qubit leakage. Qubit leakage manifests due to the fact that most systems utilized for qubits do not consist of just two levels. For example, figure 1 (from [Ste97b]) illustrates the energy level structure for a ⁴³Ca⁺ ion utilized for ion trap quantum computing. The qubits in this system are defined with two electronic states, however the system itself contains many more levels (including some which are used for qubit readout and initialization). As with systematic errors, leakage can occur when improper control is applied to such a system. In the case of ion-traps, qubit transitions are performed by focusing finely tuned lasers resonant on the relevant transitions. If the laser frequency fluctuates or additional levels are not sufficiently detuned from the qubit resonance, the following transformation could occur,

$$\begin{equation} U{\left\vert{0}\right\rangle} = \alpha{\left\vert{0}\right\rangle} + \beta{\left\vert{1}\right\rangle} + \gamma{\left\vert{2}\right\rangle}, \end{equation} \tag{ 24 }$$

where the state |2〉 is a third level, which is now populated due to improper control. The actual effect of this type of error can manifest in several different ways. As quantum circuits and algorithms are fundamentally designed assuming the computational array is of a 2-level system, the transformation shown in equation (24) (which in this case is operating over a 3-level space) will naturally induce unwanted dynamics. Another important implication of applying non-qubit operations is how these levels interact with the environment and hence how decoherence affects the system. For example, in the above case, the unwanted level, |2〉, may be extremely short lived leading to an emission of a photon and the system relaxing back to the ground state. For these reasons, leakage is one of the most problematic error channels to correct using QEC. In general, leakage induced errors need to be corrected in a similar manner to loss, which can also be thought of as a leakage process into a vacuum state. Non-demolition techniques are first required to determine if the system is still confined to the qubit subspace [Pre98, GBP97, VWW05] after which standard correction protocols can be utilized. As with qubit loss, if these additional protocols are employed, leakage errors are heralded and the performance of the resulting error correction will increase.

Zoom In Zoom Out Reset image size

Another well known method is to use a complicated pulse sequence which acts to re-focus an improperly confined operation back to the qubit subspace [WBL02, BLWZ05]. This can be advantageous as it does not require additional qubit resources.

Leakage effects arise from multiple sources, and the best method for correction is often heavily dependent on the error mechanisms. One example is when internal fluctuations in the system change otherwise perfect qubit dynamics. Unfortunately this leakage source generally cannot be predicted and/or characterized and so dedicated leakage protection will need to be employed. A second source is imprecise fabrication of an otherwise perfect qubit system. This source of leakage can, in principal, be engineered away, thereby eliminating the need for specialized leakage correction. In the context of mass manufacturing of qubit systems, leakage would ideally be quantified immediately after the fabrication of a device [DSO⁺07] to eliminate these systematic leakage errors. If a particular system was found to be improperly confined to the qubit subspace, it would simply be discarded. Employing characterization at this stage could potentially eliminate the need to implement a large amount of leakage protection in the computer, shortening gate times and ultimately reducing error rates in the computer.

In this section we have presented a very basic set of examples to explain some of the ideas of quantum errors and how they affect the success of a quantum algorithm. Section 9 will return to a more realistic set of error models. For those interested in a more complete treatment of quantum errors we encourage readers to refer to [Got97, NC00, Got02, KLA⁺02, Ste01, Got09].

Using the stabilizer structure for QEC codes, the logical state preparation and error correcting procedure is straightforward. Recall that valid codeword states are defined as simultaneous +1 eigenstates of each generator of the stabilizer group. In order to prepare a logical state from an arbitrary input, we need to project qubits into eigenstates of each of these operators.

Consider the circuit shown in figure 7. For an arbitrary input state, |ψ〉_I, an ancilla which is initialized in the |0〉 state is used as a control qubit for a unitary and Hermitian operation (U^† = U, U² = I) on |ψ〉_I. After the second Hadamard gate is performed, the state of the system is,

$$\begin{equation} {\left\vert{\psi}\right\rangle}_F = \case{1}{2} ( {\left\vert{\psi}\right\rangle}_I + U{\left\vert{\psi}\right\rangle}_I){\left\vert{0}\right\rangle} + \case{1}{2}({\left\vert{\psi}\right\rangle}_I - U{\left\vert{\psi}\right\rangle}_I){\left\vert{1}\right\rangle}. \end{equation} \tag{ 51 }$$

The ancilla qubit is then measured in the computational basis. If the result is |0〉, the input state is projected to (neglecting normalization),

$$\begin{equation} {\left\vert{\psi}\right\rangle}_F = {\left\vert{\psi}\right\rangle}_I+U{\left\vert{\psi}\right\rangle}_I. \end{equation} \tag{ 52 }$$

Since U is unitary and Hermitian, U|ψ〉_F = |ψ〉_F, hence |ψ〉_F is a +1 eigenstate of U. If the ancilla is measured to be |1〉, then the input is projected to the state,

$$\begin{equation} {\left\vert{\psi}\right\rangle}_F = {\left\vert{\psi}\right\rangle}_I-U{\left\vert{\psi}\right\rangle}_I, \end{equation} \tag{ 53 }$$

which is the −1 eigenstate of U. Therefore, provided U is Hermitian, the general circuit of figure 7 will project an arbitrary input state to a ±1 eigenstate of U⁶. This procedure is well known and is referred to as either a 'parity' or 'operator' measurement [NC00].

Zoom In Zoom Out Reset image size

From this construction it should be clear how QEC state preparation proceeds. Taking the [[7, 1, 3]] code as an example (the following technique is not unique or optimal for preparing and correcting the 7-qubit code [Ste97a, Ste02] but once this idea is understood, readers should have little difficultly understanding other correction techniques), 7-qubits are first initialized in the state |0〉^⊗7. The circuit shown in figure 7 is applied three times with U = K¹, K², K³, projecting the input state into a simultaneous ±1 eigenstate of each X generator of the stabilizer group for the [[7, 1, 3]] code. The result of each operator measurement is then used to classically control a single qubit Z gate which is applied to one of the seven qubits at the end of the preparation. This single Z gate converts any −1 projected eigenstates into +1 eigenstates. Notice that the final three stabilizers do not need to be measured due to the input state, |0〉^⊗7, already being a +1 eigenstate of K⁴, K⁵ and K⁶. Additionally as the state |0〉^⊗7 is also a +1 eigenstate of K₇, the initial state will be |0〉_L state. Figure 8 illustrates the final circuit, where instead of one ancilla, three are utilized to speed up the state preparation by performing each operator measurement in parallel.

Zoom In Zoom Out Reset image size

As a quick aside, let us detail exactly how the relevant logical basis states can be derived from the stabilizer structure of the code by utilizing this preparation procedure. We will use the stabilizer set shown in table 7 to calculate the |0〉_L state for the 5-qubit code as we have not yet explicitly shown the state vectors for the two logical state. The four stabilizer generators are given by,

$$\begin{eqnarray} &&K^1 = XZZXI, \tqs K^2 = IXZZX,\\ &&K^3 = XIXZZ, \tqs K^4 = ZXIXZ. \end{eqnarray} \tag{ 54 }$$

In an identical way to the 7-qubit code, projecting an arbitrary state into a +1 eigenstate of these operators defines the two logical basis states, |0〉_L and |1〉_L. The logical operator, $\bar{Z} = ZZZZZ$, then fixes the state to either |0〉_L or |1〉_L. Therefore, calculating |0〉_L from some initial unencoded state requires us to project the initial state into a +1 eigenstate of these operators. If we take the initial, unencoded state as |00000〉, then it is already a +1 eigenstate of $\bar{Z}$. Therefore, to find |0〉_L we simply calculate

$$\begin{equation} {\left\vert{0}\right\rangle}_L=\prod_{i=1}^4 (I^{\otimes 5} + K^i){\left\vert{00000}\right\rangle}, \end{equation} \tag{ 55 }$$

up to normalization. Expanding out this product, we find,

$$\begin{eqnarray} \fl {\left\vert{0}\right\rangle}_L &= \case{1}{4}({\left\vert{00000}\right\rangle}+{\left\vert{01010}\right\rangle}+{\left\vert{10100}\right\rangle}-{\left\vert{11110}\right\rangle}\nonumber\\ &\quad+\,{\left\vert{01001}\right\rangle}-{\left\vert{00011}\right\rangle}-{\left\vert{11101}\right\rangle}-{\left\vert{10111}\right\rangle}\nonumber\\ &\quad+\,{\left\vert{10010}\right\rangle}-{\left\vert{11000}\right\rangle}-{\left\vert{00110}\right\rangle}-{\left\vert{01100}\right\rangle}\nonumber\\ &\quad-\,{\left\vert{11011}\right\rangle}-{\left\vert{10001}\right\rangle}-{\left\vert{01111}\right\rangle}+{\left\vert{00101}\right\rangle}). \end{eqnarray} \tag{ 56 }$$

Note that the above state vector does not match up with those given in [LMPZ96]⁷. However, these vectors are equivalent up to local rotations on each qubit.

Error correction using stabilizer codes is an extension of the state preparation. Consider an arbitrary single qubit state that has been encoded as

$$\begin{equation} \alpha{\left\vert{0}\right\rangle} + \beta{\left\vert{1}\right\rangle} \rightarrow \alpha{\left\vert{0}\right\rangle}_L + \beta{\left\vert{1}\right\rangle}_L = {\left\vert{\psi}\right\rangle}_L. \end{equation} \tag{ 57 }$$

Now assume that an error occurs on one (or multiple) qubits which is described via the operator E, where E is a combination of X and/or Z errors over the N physical qubits of the logical state (and therefore an element of the N-qubit Pauli group, $\mathcal{P}_N$). By definition of stabilizer codes, Kⁱ|ψ〉_L = |ψ〉_L, i ∈ [1, .., N − k], for a code encoding k logical qubits. Hence the erred state, E|ψ〉_L, satisfies,

$$\begin{equation} K^iE{\left\vert{\psi}\right\rangle}_L = (-1)^m EK^i{\left\vert{\psi}\right\rangle}_L = (-1)^m E{\left\vert{\psi}\right\rangle}_L, \end{equation} \tag{ 58 }$$

where m is defined as m = 0, if [E, Kⁱ] = 0 and m = 1, if {E, Kⁱ} = 0 (E and K are Pauli group operators and all Pauli group operators either commute or anti-commute). Therefore, if the error operator commutes with the stabilizer, the state remains a +1 eigenstate of Kⁱ, if the error operator anti-commutes with the stabilizer then the logical state is flipped to a −1 eigenstate of Kⁱ.

The general procedure for error correction is identical to state preparation. Each of the code stabilizers is sequentially measured. Since an error free state is already a +1 eigenstate of all the stabilizers, errors which anti-commute with any of the stabilizers describing the code will flip the relevant eigenstate and consequently measuring the parity of these stabilizers will return a result of |1〉. Taking the [[7, 1, 3]] code as an example, if the error operator is E = X_i (where i = 1, ..., 7), representing a bit-flip on any one of the 7 physical qubits, then regardless of the location, E will anti-commute with a unique combination of K⁴, K⁵ and K⁶. Hence the classical results of measuring these three operators will indicate if and where a single X error has occurred. Similarly, if E = Z_i, then the error operator will anti-commute with a unique combination of, K¹, K² and K³. Consequently, the first three stabilizers for the [[7, 1, 3]] code correspond to Z error correction while the second three stabilizers correspond to X error correction. Note that correction for Pauli Y errors is achieved by correcting in the X and Z sector since a Y error on a single qubit is equivalent to both an X and Z error on the same qubit, i.e. Y = iXZ.

The circuit shown in figure 9 illustrates the circuit for full error correction with the [[7, 1, 3]] code. As you can see it is simply an extension of the preparation circuit shown in figure 8, where all six stabilizers are measured across the data block. Even though we have specifically used the [[7, 1, 3]] code as an example, this procedure for error correction and state preparation will work for all stabilizer codes (although other correction procedures are possible [Ste97a, Ste02, Kni05]).

Zoom In Zoom Out Reset image size

We have already shown a primitive example of how systematic gate errors are digitized into a discrete set of Pauli operators in section 3. However, in that case we only considered a very restrictive type of error, namely the coherent operator U = exp(i X). We can easily extend this analysis to cover all types of systematic gate errors. Consider an N qubit unitary operation, U_N, which is valid on encoded data. Assume that U_N is applied inaccurately such that the resultant operation is actually $\mathcal{U}_N$. Given a general encoded state |ψ〉_N, the final state can be expressed as

$$\begin{equation} \mathcal{U}_N {\left\vert{\psi}\right\rangle}_L = U_E U_N {\left\vert{\psi}\right\rangle}_L = \sum_j \alpha_j E_j {\left\vert{\psi_2}\right\rangle}_L, \end{equation} \tag{ 59 }$$

where |ψ₂〉_L = U_N|ψ〉_L is the perfectly applied N qubit gate, (the stabilizer group for |ψ'〉_L remains invariant under the operation U_N (see section 11)) and U_E is a coherent error operator which is expanded in terms of the N qubit Pauli Group, E_j ∈ P_N. Now append two ancilla blocks, |A₀〉^X and |A₀〉^Z. These are generally initialized to the state that corresponds to no detected errors (but can be other initial states up to a redefinition of the measurement results) and are used for X and Z correction. We then run the syndrome extraction procedure, which we represent by the unitary operator, U_QEC. It will be assumed that |ψ〉_L is encoded with a QEC code which can correct for a single error (both X and/or Z), and the error operators E_j are a maximum of weight one (i.e. E_j contains at most one non-identity term e.g. E₁ = X₁ ⊗ I ^⊗ (N−1)) ⁸, hence there is a one-to-one mapping between the error operators, E_j, and the orthogonal basis states of the ancilla blocks,

$$\begin{eqnarray} &U_{{\rm QEC}}U_N'{\left\vert{\psi}\right\rangle}_L{\left\vert{A_0}\right\rangle}^X{\left\vert{A_0}\right\rangle}^Z\nonumber\\ \quad &= U_{{\rm QEC}} \sum_j \alpha_jE_j{\left\vert{\psi'}\right\rangle}_L {\left\vert{A_0}\right\rangle}^X{\left\vert{A_0}\right\rangle}^Z\nonumber\\ \quad &= \sum_j \alpha_j E_j {\left\vert{\psi'}\right\rangle}_L{\left\vert{A_j}\right\rangle}^X{\left\vert{A_j}\right\rangle}^Z. \end{eqnarray} \tag{ 60 }$$

The above assumes a non-degenerate quantum code⁹. The ancilla blocks are then measured, projecting the data blocks into the state E_j|ψ'〉_L with probability |α_j|². After measurement the correction $E_j^{\dagger}$ is applied based on the syndrome result. As the error operation E_j is simply an element of $\mathcal{P}_N$, correcting for X and Z independently is sufficient to correct for all error operators (as Y errors are corrected when a bit and phase error is detected and corrected on the same qubit).

For well designed gates, very small systematic inaccuracies lead to the expansion coefficient α₀ ≈ 1, with all other coefficients, α_j≠0 ≪ 1. Hence during correction there will be a very high probability that no error is detected. This is the digitization effect of QEC. Since codeword states are eigenstates of the stabilizers, re-projecting the state when each stabilizer is measured forces any continuous noise operator to collapse. The strength of the error is then related to the probability that the data block collapses to a specific Pauli error acting on the codestate. The physical mechanisms which are used to construct quantum gates are what determine the form of U_E and hence the form of the error operators, E_j and their respective coefficients, α_j.

A complete analysis of environmental decoherence in relation to quantum information is a lengthy topic. Instead of a detailed review, we will instead present a simplified example to highlight how QEC relates to environmental effects.

The Lindblad formalism [Gar91, NC00, DWM03] provides an elegant method for analysing the effect of decoherence on open quantum systems. This model does have several assumptions, most notably that the environmental bath couples weakly to the system (Born approximation), the system and environment are initially in some separable state and that each qubit experiences temporally un-correlated noise (Markovian approximation). While these assumptions are utilized for a variety of systems [BHPC03, BM03, BKD04], it is known that they may not hold in some cases [HMCS00, MCM⁺05, APN⁺05, ALKH02]. This is particularly important in superconducting systems, where decoherence can be caused by small numbers of fluctuating charges which induces coloured noise therefore violating the assumption of non-Markovian dynamics. In this case more specific decoherence models need to be considered.

Using this formalism, the evolution of the density matrix can be written as

$$\begin{equation} \partial_t \rho = -\frac{\rmi}{\hbar} [H,\rho] + \sum_k \Gamma_k \mathcal{L}_k[\rho], \end{equation} \tag{ 61 }$$

where H is the Hamiltonian, representing coherent, dynamical evolution of the system and $\mathcal{L}_k[\rho]=([L_k,\rho L_k^{\dagger}]+[L_k\rho, L_k^{\dagger}])/2$ represents the incoherent evolution. The operators L_k are known as the Lindblad quantum jump operators and are used to model specific decoherence channels, with each operator associated with some rate Γ_k ⩾ 0. This differential equation is known as the quantum Liouville equation or more generally, the density matrix master equation.

To link Markovian decoherence to QEC, consider a special set of decoherence channels which represent a single qubit undergoing dephasing, spontaneous emission and spontaneous absorption. This helps to simplify the calculation. Dephasing of a single qubit is modelled by the Lindblad operator L₁ = Z while spontaneous emission/absorption are modelled by the operators L₂ = |0〉〈1| and L₃ = |1〉〈0|, respectively. For the sake of simplicity, we assume that absorption/emission occur at the same rate, Γ. Although this is unphysical, it does simplify the calculation significantly for this example. The density matrix evolution is given by,

$$\begin{equation} \partial_t \rho = -\frac{\rmi}{\hbar}[H,\rho] + \Gamma_Z (Z\rho Z - \rho) + \frac{\Gamma}{2}(X\rho X + Y\rho Y -2\rho). \end{equation} \tag{ 62 }$$

If we assumed that the qubit is not undergoing any coherent evolution (H = 0), i.e. a memory stage within a quantum algorithm, then equation (62) can be solved by re-expressing the density matrix in the Bloch formalism. Set ρ(t) = I/2 + x(t)X + y(t)Y + z(t)Z, then equation (62) with H = 0 reduces to ∂_tS(t) = AS(t) with S(t) = (x(t), y(t), z(t))^T and

$$\begin{equation} A = \left(\begin{array}{@{}lll@{}} -(\Gamma + 2\Gamma_z) & 0 &0 \\ 0 &-(\Gamma + 2\Gamma_z) &0\\ 0 &0 &-2\Gamma \end{array}\right). \end{equation} \tag{ 63 }$$

This differential equation is easy to solve, leading to

$$\begin{eqnarray} \fl \rho(t) &= [1-p(t)]\rho(0) + p_x(t) X\rho(0) X\nonumber\\ &\quad +\,p_y(t) Y \rho(0) Y + p_z(t) Z \rho(0) Z, \end{eqnarray} \tag{ 64 }$$

where,

$$\begin{eqnarray} p_x(t) = &p_y(t) = \case{1}{4}(1-\rme^{-2\Gamma t}),\nonumber\\ &p_z(t) = \case{1}{4}(1+\rme^{-2\Gamma t}-2\rme^{-(\Gamma +2\Gamma_z)t}),\nonumber\\ &p(t) = p_x(t) + p_y(t) + p_z(t). \end{eqnarray} \tag{ 65 }$$

If this single qubit is part of an encoded data block, then each term represents a single error on the qubit experiencing decoherence. Two blocks of ancilla qubits, initialized to the state corresponding to no detected error, are added to the system. The error correction protocol is then run. Once the ancilla qubits are measured, the state will collapse to no error with probability 1 − p(t), or a single X, Y or Z error, with probabilities p_x(t), p_y(t) and p_z(t) respectively. Although the above example is somewhat artificial, the above should allow the reader to perform their own calculations for expected QEC error rates given a more physical complete error model.

We can also see how temporal effects are incorporated into the error correction model. The temporal integration window t of the master equation will influence how probable an error is detected for a fixed rate Γ. The longer between correction cycles, the more probable the qubit experiences an error.

Both the systematic gate errors and the errors induced by environmental decoherence illustrate the digitization effect of QEC. However, we can generalize digitization to other mappings of the density matrix. In this case consider a more general Krauss map on a multi-qubit density matrix,

$$\begin{equation} \rho \rightarrow \sum_k A_k^{\dagger}\rho A_k, \end{equation} \tag{ 66 }$$

where $\sum A_k^{\dagger}A_k = I$. For the sake of simplicity let us choose a simple mapping where $A_1 = (Z_1+\rmi Z_2)/\sqrt{2}$ and A_k = 0 for k ≠ 1. This mapping essentially represents dephasing on two qubits. However, this type of mapping (when considered in the context of error correction) represents independent Z errors on either qubit one or two.

The above discussion assumes that we are working with a non-degenerate quantum code. If the code is degenerate, i.e. if the errors Z₁ and Z₂ have the same effect on the codestates then the correction protocol does not simplify this error mapping as described above.

To illustrate, first expand out the density matrix (neglecting normalization),

$$\begin{equation} \rho \rightarrow A_1^{\dagger}\rho A_1 = Z_1\rho Z_1 + Z_2\rho Z_2 - \rmi Z_1\rho Z_2 + \rmi Z_2 \rho Z_1. \end{equation} \tag{ 67 }$$

Note that only the first two terms in this expansion, on their own, represent physical mixtures. However, the last two off-diagonal terms are removed by the process of syndrome extraction and are irrelevant in the context of QEC. To illustrate, we assume that ρ represents a protected qubit, where Z₁ and Z₂ are physical errors on qubits comprising the code block. As we are only considering phase errors in this example, we will ignore X correction (but the analysis automatically generalizes if the error mapping contains X terms). A fresh ancilla block, represented by the density matrix $\rho^z_0$, is coupled to the system and the unitary U_QEC is run,

$$\begin{eqnarray} U_{QEC}^{\dagger}\rho'\otimes \rho^z_0 U_{QEC} &= Z_1\rho Z_1 \otimes {\left\vert{Z_1}\right\rangle}{\left\langle{Z_1}\right\vert}\nonumber\\ &\quad +\,Z_2\rho Z_2 \otimes {\left\vert{Z_2}\right\rangle}{\left\langle{Z_2}\right\vert}\nonumber\\ &\quad -i\,Z_1\rho Z_2 \otimes {\left\vert{Z_1}\right\rangle}{\left\langle{Z_2}\right\vert}\nonumber\\ &\quad +\,iZ_2\rho Z_1 {\left\vert{Z_2}\right\rangle}{\left\langle{Z_1}\right\vert}, \end{eqnarray} \tag{ 68 }$$

where |Z₁〉 and |Z₂〉 represent the two orthogonal syndrome states of the ancilla that are used to detect phase errors on qubits one and two respectively. The important part of the above expression is that when the syndrome qubits are measured, the state collapses to,

$$\begin{eqnarray} &\rho \rightarrow \frac{{\left\langle{Z_1}\right\vert}\rho{\left\vert{Z_1}\right\rangle}{\left\vert{Z_1}\right\rangle}{\left\langle{Z_1}\right\vert}}{{\rm Tr}(\rho {\left\vert{Z_1}\right\rangle}{\left\langle{Z_1}\right\vert})}\nonumber\\ {\rm or} &\rho \rightarrow \frac{{\left\langle{Z_2}\right\vert}\rho{\left\vert{Z_2}\right\rangle}{\left\vert{Z_2}\right\rangle}{\left\langle{Z_2}\right\vert}}{{\rm Tr}(\rho {\left\vert{Z_2}\right\rangle}{\left\langle{Z_2}\right\vert})}. \end{eqnarray} \tag{ 69 }$$

The two cross terms in the above expression are never observed. In this mapping the only two possible states that exist after the measurement of the ancilla system are,

$$\begin{eqnarray} &&Z_1\rho Z_1 \otimes {\left\vert{Z_1}\right\rangle}{\left\langle{Z_1}\right\vert} \quad {\rm with\ Probability} =\case{1}{2}, \\ &&Z_2\rho Z_2 \otimes {\left\vert{Z_2}\right\rangle}{\left\langle{Z_2}\right\vert} \quad {\rm with\ Probability} =\case{1}{2}. \end{eqnarray} \tag{ 70 }$$

Therefore, not only are the cross terms eliminated via error correction but the final density matrix again collapses to a single error perturbation of 'clean' codeword states with no correlated errors.

Consequently, it is common in standard QEC analysis to assume that discrete X and/or Z errors are applied stochastically to each qubit after each elementary gate operation, measurement, initialization and memory step with some probability p. The QEC protocol itself digitizes the continuous noise, either coherent or incoherent errors, into a discrete set of bit and/or phase flips. The set of discrete errors is determined by the set of errors that are distinguishable by the quantum code used. The magnitude of the continuous error is translated to the probability of detecting a discrete error. In this way error correction can be analysed by assuming perfect gate operations and discrete, probabilistic errors. The probability of these errors occurring can then be independently calculated via analysis of the physical mechanisms which produce errors. While a local, stochastic error model is generally the most common, depending on the physical system under consideration and the type of quantum codes being used a more complicated analysis may be needed [Pre98].

Before discussing the nature of fault-tolerant computation, we first examine how errors can propagate in quantum circuits. There are essentially two dominant channels that can cause errors to be copied: the first is quantum gates. For obvious reasons, gates operating on single qubits do not copy errors, however quantum gates which couple qubits can cause errors to propagate.

For example, take the two qubit state E_j|ψ〉, where E_j = {X₁I₂, Y₁I₂, Z₁I₂, I₁X₂, I₁Y₂, I₁Z₂} are each single qubit errors (either on qubit one or two respectively). We now perform a CNOT operation, U = CNOT, where the control is qubit one. This gives,

$$\begin{equation} UE_j{\left\vert{\psi}\right\rangle} = (UE_jU^{\dagger})U{\left\vert{\psi}\right\rangle}, \end{equation} \tag{ 71 }$$

using the identity (U^†U) = I. The effect of the gate is to transform the error E_j to E'_j = (UE_jU^†). For the six single qubit errors, this gives

$$\begin{eqnarray} &&U(X_1I_2)U^{\dagger} = X_1X_2,\\ &&U(Y_1I_2)U^{\dagger} = Y_1X_2,\\ &&U(Z_1I_2)U^{\dagger} = Z_1I_2,\\ &&U(I_1X_2)U^{\dagger} = I_1X_2,\\ &&U(I_1Y_2)U^{\dagger} = Z_1Y_2,\\ &&U(I_1Z_2)U^{\dagger} = Z_1Z_2. \end{eqnarray} \tag{ 72 }$$

Therefore, the CNOT gate copies X errors from the control qubit to the target and copies Z errors from the target to the control. Error propagation rules for any multi-qubit unitary can also be calculated for an arbitrary gate, U, and error, E¹⁰.

The above example assumes a perfect 2-qubit gate operation, however the gates themselves can also introduce multiple errors when they fail. In the case of coherent errors, an arbitrary 2-qubit unitary, U, can be written in the form, U_EU_p, where U_p is the perfectly applied gate and U_E is some coherent error operator. This error operator can be expressed as a linear combination of the 2-qubit Pauli group,

$$\begin{equation} U_E = \sum_{(i,j)=1}^{4} d_{i,j} \; \sigma_i\otimes \sigma_j, \tqs [\sigma_1,\sigma_2,\sigma_3,\sigma_4] = [I,X,Y,Z]. \end{equation} \tag{ 73 }$$

Therefore inaccurate application of the gate U_p (including complete failure) can introduce a single X, Y or Z error to each of the two qubits or it can introduce an error to both qubits (the details of what kind of errors can be introduced by faulty gates are dependent on the mechanisms causing the failure). Therefore, not only can gates coupling qubits copy pre-existing errors but a single failure event can introduce errors on both qubits involved in the interaction. Correlated errors also occur in the density matrix representation when incoherent noise causes gate inaccuracies. This generalizes for higher order operations, e.g. errors on three qubit gates can introduce errors on all three qubits, etc.

A second process which can cause errors to cascade is the classical correction of quantum data from a measurement result¹¹. Take the circuit shown in figure 10. The measurement result on the top qubit is used to determine if the gate, X, is applied to the second qubit. In this case the gate is applied if the upper qubit is measured in the state |1〉. If we now assume that this measurement is faulty, then with some probability the 'classical' information extracted from the measurement device is wrong. Therefore the correction that is applied to the second qubit should not have been applied. Not only has a bit-flip error now occurred on qubit one (due to the inaccurate measurement result), but we also have accidentally introduced a bit-flip error on the second qubit due to this inaccurate information.

Zoom In Zoom Out Reset image size

Hence gates which couple qubits and measurement errors (which subsequently control further quantum gates) can copy errors from qubit to qubit.

Concatenation is where a group of encoded qubits are further encoded (not necessarily with the same error correction code). This forms a second level encoded qubit which figure 11 illustrates for the [[7, 1, 3]] code. Starting with a group of unencoded qubits, we first encode into level-1 logical qubits, each containing a block of seven. Each of these logical qubits are now protected with a distance three quantum code. If we now take seven of these level-1 logical qubits and perform the same encoding operation (using valid encoded gate operations, discussed in the following sections) we form a level-2 logical qubit. This is now a block containing 49 physical qubits and has a code distance of 3² = 9. A level-2 logical qubit can therefore be faithfully recovered if four or less errors occur on any of the 49 physical qubits. This process can be repeated indefinitely, for g levels of concatenation, the encoded state will consist of 7^g physical qubits and have a code distance of 3^g, allowing for the correction of (3^g − 1)/2 individual errors. Hence for a concatenation scheme, both the number of physical qubits required and the number of errors it can correct scale exponentially (with the number of qubits growing faster than the number of correctable errors).

Zoom In Zoom Out Reset image size

The concept of fault-tolerance in computation is not a new idea, it was first developed in relation to classical computing [Neu55, G83, Avi87]. However, in recent years the precise manufacturing of digital circuitry has made large-scale error correction and fault-tolerant circuits largely unnecessary.

The basic principle of fault-tolerance is that the circuits used for gate operations and error correction procedures should not cause errors to cascade. As shown in the previous section, gates which couple multiple qubits and measurements which are used to control a quantum operation can cause errors to be copied. How do we design operations to avoid cascading errors in quantum algorithms?

This can be seen more clearly when we look at a simple CNOT operation between two qubits (figure 12). In this circuit we are performing a sequence of three CNOT gates which act to take the state |111〉|000〉 → |111〉|111〉. In figure 12(a) we consider a single X error which occurs on the top most qubit prior to the first CNOT. This single error will cascade through each of the three gates such that the X error has now propagated to four qubits. Figure 12(b) shows a slightly modified design that implements the same operation, but the single X error now only propagates to two of the six qubits. If we consider each block of three as a single logical qubit, then the staggered circuit will only induce a total of one error in each logical block, given a single X error occurred somewhere during the circuit. Therefore, one of the standard definitions of fault-tolerance is

fault-tolerant circuit element: A single error will cause at most one error in the output for each logical qubit block.

It should be stressed that the idea of fault-tolerance is a discrete definition: either a certain quantum operation is fault-tolerant or it is not. What is defined to be fault-tolerant can change depending on the error correction code used. For example, for a single error correcting code, the above definition is the only one available, since any more than one error in a logical qubit will result in the error correction procedure failing. However, if the quantum code employed is able to correct multiple errors, then the definition of fault-tolerance can be relaxed, i.e. if the code can correct three errors then circuits may be designed such that a single failure results in at most three errors in the output (which is then correctable). In general, for a code correcting t = ⌊(d − 1)/2⌋ errors, fault-tolerance requires that ⩽t errors during an operation does not result in > t errors in the output for each logical qubit.

Zoom In Zoom Out Reset image size

The threshold theorem is truly a remarkable result in quantum information and is a consequence of fault-tolerant circuit design and the ability to perform dynamical error correction. Rather than present a detailed derivation of the theorem for a variety of noise models, we will instead take a very simple case where we utilize a quantum code that can only correct for a single error, using a model that assumes uncorrelated errors on individual qubits. For more rigorous derivations of the theorem see [ABO97, Got97, Ali07].

Consider a quantum computer where each physical qubit experiences either an X and/or Z error independently with probability p, per gate operation. Furthermore, it is assumed that logical gate operations and error correction circuits are designed according to the rules of fault-tolerance and that a cycle of error correction is performed after each elementary logical gate operation using a code that corrects for a single error ([[n, k, 3]] code). If an error occurs during a logical gate operation, then fault-tolerance ensures this error will only propagate to at most one error in each block, after which a cycle of error correction will remove the error. Hence if the failure probability of unencoded qubits per time step is p, then a single level of error correction will ensure that the logical step fails only when two (or more) errors occur. Hence the failure rate of each logical operation, to leading order, is now $p^1_L = cp^2$, where $p^1_L$ is the failure rate (per logical gate operation) of a level-1 logical qubit and c is the upper bound for the number of possible 2-error combinations which can occur at a physical level within the sequence of operations consisting of a correction cycle, the logical gate operation and a second correction cycle [Ali07]. We now concatenate, encoding the computer further, such that a level-2 logical qubit is formed. We assume this is done using the same [[n, k, 3]] quantum code level-1 encoded qubit. It is assumed that all error correcting procedures and gate operations at level-2 are self-similar to the level-1 operations (i.e. the circuit structures for the level-2 encoding are identical to the level-1 encoding). Therefore, if the level-1 failure rate per logical time step is $p^1_L$, then by the same argument, the failure rate of a level-2 operation is given by, $p^2_L = c(p^1_L)^2 = c^3p^4$. This iterative procedure is then repeated up to level-g, such that the logical failure rate, per time step, of a level-g encoded qubit is given by

$$\begin{equation} p^g_L = \frac{(cp)^{2^g}}{c}. \end{equation} \tag{ 74 }$$

Equation (74) implies that for a finite physical error rate, p, per qubit, per time step, the failure rate of a level-g encoded qubit can be made arbitrarily small if cp < 1. This inequality defines the threshold. The physical error rate experienced by each qubit per time step must be p_th < 1/c to ensure that multiple levels of concatenated error correction reduce the failure rate of logical components.

Hence, provided sufficient resources are available, an arbitrarily large quantum circuit can be successfully implemented to arbitrary accuracy, once the physical error rate is below threshold. The calculation of thresholds is therefore an extremely important aspect to quantum architecture design. Initial estimates at the threshold, which gave p_th ≈ 10⁻⁴–10⁻⁶ [Kit97, ABO97, Got97], did not sufficiently model the physical architectures. Recent results [SFH08, SDT07, SBF⁺06, MCT⁺04, BKSO05] have been estimated for more realistic quantum processor architectures, showing significant differences in threshold when architectural considerations are taken into account. Many of these estimates are summarized in table 8 with a brief description of the constraints considered by the model. We order the entries by the level of detail presented in each of the papers with regards to physical implementation of fault-tolerant error correction protocols on realistic quantum architectures.

From the above table you can see the differences in threshold that occur once more specific architectural considerations are taken into account. This variation is heavily dependent on what error models are assumed in the analysis, if qubit transport can be done directly (such as in ion traps where the qubits are physically moved throughout the computational array) or via the application of SWAP gates (required in condensed matter systems such as P : Si, quantum dots or NV defects in diamond) and what is the structure of the QEC code that is ultimately used. In terms of concatenated QEC codes, the majority of analysis was done using the [[7, 1, 3]] Steane code and only the results of Knill [Kni05] show a threshold of the order of 1%. However, the results of Knill have not yet been adapted to a physical architecture and it remains unclear if the constraints of a 1D, 2D or 3D nearest neighbour architecture will reduce the threshold to that of other concatenated codes and/or substantially increase qubit resources to achieve a high threshold.

Currently, the most detailed architectural designs are based on topological cluster codes [RHG07] and surface codes [Kit97, DKLP02, FSG09]. The general framework for this type of error correction is discussed later in section 14.2. These codes are promising for large-scale computers as they exhibit significantly higher thresholds to concatenation and they have an intrinsic structure that is compatible with 2D or 3D nearest neighbour architectures.

For an elementary operation A, the equivalent logical operator $\bar{A}$ will now be formed via a sequence of elementary operations on the physical qubits comprising the code block. The logical $\bar{X}$ and $\bar{Z}$ operations on a single encoded qubit are the first examples of valid codeword operations. Taking the [[7, 1, 3]] code as an example, $\bar{X}$ and $\bar{Z}$ are given by,

$$\begin{eqnarray} &&\bar{X} = XXXXXXX \equiv X^{\otimes 7},\\ &&\bar{Z} = ZZZZZZZ \equiv Z^{\otimes 7}. \end{eqnarray} \tag{ 76 }$$

Since the single qubit Pauli operators satisfy XZX = −Z and ZXZ = −X then, $\bar{X}K^{i}\bar{X} = K^{i}$ and $\bar{Z}K^{i}\bar{Z} = K^{i}$ for each of the [[7, 1, 3]] stabilizers given in equation (50). The fact that each stabilizer has a weight of four guarantees that UKU^† picks up an even number of −1 factors. Since the stabilizers remain fixed, the operations are valid. However, what transformations do equation (76) actually perform on encoded data?

For a single qubit, a bit-flip operation X takes |0〉 ↔ |1〉. Recall that for a single qubit Z|0〉 = |0〉 and Z|1〉 = −|1〉, hence for $\bar{X}$ to actually induce a logical bit-flip it must take, |0〉_L ↔ |1〉_L. For the [[7, 1, 3]] code, the final operator which fixes the logical state is K⁷ = Z^⊗7, where K⁷|0〉_L = |0〉_L and K⁷|1〉_L = −|1〉_L. As $\bar{X}K^7\bar{X} = -K^7$, any state stabilized by K⁷ becomes stabilized by −K⁷ (and vice-versa) after the operation of $\bar{X}$. Therefore, $\bar{X}$ represents a logical bit flip. The same argument can be used for $\bar{Z}$ by considering the stabilizer properties of the states ${\left\vert{\pm}\right\rangle} = ({\left\vert{0}\right\rangle} \pm {\left\vert{1}\right\rangle})/\sqrt{2}$. Hence, the logical bit- and phase-flip gates can be applied directly to logical data by simply using seven single qubit X or Z gates (figure 13).

Zoom In Zoom Out Reset image size

Two other useful gates which can be applied in this manner are the Hadamard rotation and phase gates,

$$\begin{equation} H = \case{1}{\sqrt{2}} \left(\begin{array}{@{}ll@{}} 1 & 1 \\ 1 & -1 \end{array}\right), \tqs P = \left(\begin{array}{@{}ll@{}} 1 & 0 \\ 0 & \rmi \end{array}\right). \end{equation} \tag{ 77 }$$

These gates are useful since when combined with the two-qubit CNOT gate, they can generate a subgroup of all multi-qubit gates known as the Clifford group (gates which map Pauli group operators back to the Pauli group). Again, using the stabilizers of the [[7, 1, 3]] code and the fact that for single qubits,

$$\begin{eqnarray} &&HXH = Z, \tqs HZH = X, \\ &&PXP^{\dagger} = \rmi XZ, \tqs PZP^{\dagger} = Z, \end{eqnarray} \tag{ 78 }$$

a seven qubit bit-wise Hadamard gate will switch X with Z and therefore will simply flip {K¹, K², K³} with {K⁴, K⁵, K⁶}, and is a valid operation. The bit-wise application of the P gate will leave any Z stabilizer invariant, but takes X → iXZ. This is still valid, since provided there are a multiple of four non-identity operators for each generator of the stabilizer group, the factors of i will cancel. Hence seven bit-wise P gates is valid for the [[7, 1, 3]] code.

What do these logical operators do to the logical state? For a single qubit, the Hadamard gate flips any Z stabilized state to an X stabilized state, i.e. |0, 1〉 ↔ |+, −〉. Looking at the transformation of K⁷, using $\bar{H} = H^{\otimes 7}$ we have, $\bar{H}K^7\bar{H} = X^{\otimes 7}$. Therefore, the bit-wise Hadamard gate, $\bar{H}$, is the logical Hadamard operation. The single qubit P gate leaves a Z stabilized state invariant, while an X eigenstate becomes stabilized by iXZ. Hence, denoting $\bar{P}^{\dagger} = P^{\otimes 7}$, $\bar{P}(X^{\otimes 7})\bar{P}^{\dagger} = -i(XZ)^{\otimes 7}$ and the bit-wise gate, $\bar{P}^{\dagger}$, is the logical P^† gate. Similarly, bit-wise gate, $\bar{P} = P^{\dagger \otimes 7}$, enacts a logical P gate (figure 13). Each of these fault-tolerant operations on a logically encoded block are commonly referred to as transversal operations. A transversal operation can be defined as a logical operator which is formed by applying the individual physical operators to each qubit in the code block (or between two equivalent physical qubits in the case of entangling operations such as the CNOT gate shown below). The physical operations forming a transversal logical operator need not be the same, for example in figure 13, the $\bar{P}^{\dagger}$ gate is formed via individual P operations and vice versa. Hence, valid transversal gates may possibly be constructed from a set of physical operations which are unique to each qubit.

A two-qubit logical CNOT operation can also be applied in the same way, as a transversal bit-wise operation of individual CNOT gates between corresponding physical qubits. For unencoded qubits, a CNOT operation performs the following mapping on the two qubit stabilizer set,

$$\begin{eqnarray} &&X\otimes I \rightarrow X\otimes X, \\ &&I\otimes Z \rightarrow Z\otimes Z, \\ &&Z\otimes I \rightarrow Z\otimes I, \\ &&I\otimes X \rightarrow I\otimes X, \end{eqnarray} \tag{ 79 }$$

where the first operator corresponds to the control qubit and the second operator corresponds to the target. Now consider the bit-wise application of seven CNOT gates between logically encoded blocks of data (figure 14). First the stabilizer set must remain invariant,

$$\begin{equation} {\rm CNOT} \mathcal{G}{\rm CNOT} = \{{\rm CNOT} (K^{i}\otimes K^{j}) {\rm CNOT}\} = \mathcal{G}, \end{equation} \tag{ 80 }$$

i.e. each element in $\mathcal{G}$ must be mapped to another element of $\mathcal{G}$. Table 9 details the transformation for all the stabilizer generators under seven bit-wise CNOT gates, demonstrating that this operation is valid on the [[7, 1, 3]] code. The transformations in equation (79) are trivially extended to the logical space, showing that seven bit-wise CNOT gates invoke a logical CNOT operation.

$$\begin{eqnarray} &&\bar{X}\otimes I \rightarrow \bar{X}\otimes \bar{X}, \\ &&I\otimes \bar{Z} \rightarrow \bar{Z}\otimes \bar{Z}, \\ &&\bar{Z}\otimes I \rightarrow \bar{Z}\otimes I, \\ &&I\otimes \bar{X} \rightarrow I\otimes \bar{X}. \end{eqnarray} \tag{ 81 }$$

Zoom In Zoom Out Reset image size

The issue of fault-tolerance with these logical operations should be clear. The $\bar{X}$, $\bar{Z}$, $\bar{H}$, $\bar{P}^{\dagger}$ and $\bar{P}$ gates are trivially fault-tolerant since the logical operation is performed through seven bit-wise single qubit gates. The logical CNOT is also fault-tolerant since each two-qubit gate only operates between counterpart qubits in each logical block. Hence if any gate is inaccurate then, at most, a single error will be introduced in each block.

In contrast to the [[7,1,3]] code, let us also take a quick look at the [[5,1,3]] code. Unlike the 7-qubit code, the full set of Clifford gates cannot be implemented in the same transversal manner. To see this clearly we can examine how the generators of the stabilizer group for the code transforms under a transversal Hadamard operation,

$$\begin{eqnarray} \fl \begin{array}{@{}cccccc@{}} K^1 = & X & Z & Z & X & I \\ K^2 = & I & X & Z & Z & X \\ K^3 = & X & I & X & Z & Z \\ K^4 = & Z & X & I & X & Z \end{array} \quad \mathop{\longrightarrow}\limits^{H^{\otimes 5}} \quad \begin{array}{@{}ccccc@{}} Z & X& X & Z & I \\ I & Z & X & X & Z \\ Z & I & Z & X & X \\ X & Z & I & Z & X.\end{array}\nonumber\\ \end{eqnarray} \tag{ 82 }$$

The stabilizer group is not preserved under this transformation and therefore is not a valid logical operation for the [[5,1,3]] code. One thing to briefly note is that there are methods for performing logical Hadamard and phase gates on the [[5,1,3]] code [Got97]. However, they essentially involve performing a valid, transversal, three qubit gate and then measuring out two of the logical ancilla. Although it has been demonstrated that a valid set of transversal operations for universal computing is incompatible with a quantum code that corrects an arbitrary single error [EK09], it has not been shown that a non-CSS code cannot have a transversal set of operations generating the Clifford group. This example is used to illustrate the transformation for an invalid logical operation on an encoded state.

While these gates can be conveniently implemented on error protected data, they do not represent a universal set for quantum computation. In fact it has been shown that by using the stabilizer formalism, these operations can be efficiently simulated on a classical device [Got98, AG04]. In order to achieve universality one of the following gates is generally added to the available set,

$$\begin{equation} T = \left(\begin{array}{@{}ll@{}} 1 & 0 \\ 0 & e^{i\pi/4} \end{array}\right), \end{equation} \tag{ 83 }$$

or the Toffoli gate [Tof81]. Applying them in a similar transversal way, for the majority of stabilizer codes, transform the stabilizers out the group and is consequently not a valid operation. Circuits implementing these two gates in a fault-tolerant manner have been developed [NC00, GC99, SI05, SFH08], for various codes (most often the [[7, 1, 3]] code) but at this stage the circuits are complicated and resource intensive. This has practical implications for encoded operations. If universality is achieved by adding the T gate to the list, arbitrary single qubit rotations require long gate sequences (utilizing the Solovay-Kitaev theorem [Kit97, DN06]) to approximate arbitrary logical qubit rotations and these sequences often require many T gates [Fow05]. Finding more efficient methods to achieve universality on encoded data is therefore still an active area of research.

Quantum subsystem codes [KLP05, KLPL06, Bac06] are one of the newer and highly flexible techniques to implement quantum error correction. The traditional stabilizer codes that we have reviewed are more formally identified as subspace codes, where information is encoded in a relevant coding subspace of a larger multi-qubit system. In contrast, subsystem coding identifies multiple subspaces of the multi-qubit system as equivalent. Specifically, multiple states are identified with the logical |0〉_L and |1〉_L states. Rather than review the subsystem codes in general, we will focus on a subset of these codes known as Bacon–Shor codes [Bac06].

The primary benefit to utilizing Bacon–Shor [BS] codes is the general nature of their construction. The description of arbitrarily large error correcting codes is conceptually straightforward, error correction circuits are much simpler to construct [AC07], and the generality of their construction introduces the ability to perform dynamical code switching in a fault-tolerant manner [SEDH08]. This final property gives BS coding significant flexibility as the strength of error correction within a quantum computer can be changed fault-tolerantly during operation of the computer.

As with the other codes presented in this review, BS codes are stabilizer codes but now defined over a square lattice. The lattice dimensions represent the X and Z error correction properties and the size of the lattice in either of these two dimensions dictates the total number of errors the code can correct. In general, a $\mathcal{C}$ (n₁,n₂) BS code is defined over a n₁ × n₂ square lattice which encodes one logical qubit into n₁n₂ physical qubits with the ability to correct at least ⌊(n₁ − 1)/2⌋Z errors and at least ⌊(n₂ − 1)/2⌋X errors. Again, keeping with the spirit of this review, we focus on a specific example, the $\mathcal{C}$ (3,3) BS code. This code, encoding one logical qubit with nine physical qubits, can correct for one X and one Z error. In order to define the code structure we begin with a 3 × 3 lattice of qubits, where qubits are identified with the vertices of the lattice. Note that this 2D structure represents the structure of the code, it does not imply that a physical array of qubits must be arranged into a 2D lattice. Figure 18 illustrate three sets of stabilizer operators which are defined over the lattice. The first group, illustrated in figure 18(a) is the stabilizer group, $\mathcal{S}$, which is generated by the operators,

$$\begin{equation} \mathcal{S} = \langle X_{i,*} X_{i+1,*} ; Z_{*,j}Z_{*,j+1} \ | \ i \in {\mathbb Z}_{2} ; j \in {\mathbb Z}_{2} \rangle, \end{equation} \tag{ 89 }$$

where we retain the notation utilized in [AC07, SEDH08]. U_i,* and U_*,j represent an operator, U, acting on all qubits in a given row, i, or column, j, respectively, and ${\mathbb Z}_2=\{1,2\}$. The second relevant subsystem is known as the gauge group (figure 18(b)), $\mathcal{T}$, and is described via the non-Abelian group generated by the pairwise operators

$$\begin{equation} \mathcal{T} = \langle X_{i,j}X_{i+1,j} ; Z_{j,i}Z_{j,i+1} \ | \ i \in {\mathbb Z}_{2} ; j \in {\mathbb Z}_{3} \rangle. \end{equation} \tag{ 90 }$$

The third relevant subsystem is the logical space (figure 18(c)), $\mathcal{L}$, which can be defined through the logical Pauli operators

$$\begin{equation} \mathcal{L} = \langle Z_{*,1} ; X_{1,*} \rangle. \end{equation} \tag{ 91 }$$

Zoom In Zoom Out Reset image size

The stabilizer group $\mathcal{S}$, defines all relevant code states, i.e. every valid logical space is a +1 eigenvalue of this set. For the $\mathcal{C}$ (3,3) code, there are a total of nine physical qubits and a total of four independent stabilizers in $\mathcal{S}$, hence there are five degrees of freedom left in the system which can house 2⁵ logical states which are simultaneous eigenstates of $\mathcal{S}$. This is where the gauge group, $\mathcal{T}$, becomes relevant. As the gauge group is non-Abelian, there is no valid code state which is a simultaneous eigenstate of all operators in $\mathcal{T}$. However, if you examine closely there are a total of four encoded sets of Pauli operations within $\mathcal{T}$. Figure 18(b) illustrates two such sets. As all elements of $\mathcal{T}$ commute with all elements of $\mathcal{S}$ we can identify each of these four sets of valid 'logical' qubits to be equivalent, i.e. we define {|0〉_L, |1〉_L} pairs which are eigenstates of $\mathcal{S}$ and one Abelian subgroup of $\mathcal{T}$ and then ignore exactly what gauge group we are in¹². Therefore, each of these gauge states represent a subsystem of the code, with each subsystem logically equivalent.

The final group we consider is the logical group $\mathcal{L}$. This is the set of two Pauli operators which enact a logical X or Z gate on the encoded qubit regardless of the gauge choice and consequently represent true logical operations to our encoded space.

In a more formal sense, the definition of these three group structures allows us to decompose the Hilbert space of the system. If we let $\mathcal{H}$ denote the Hilbert space of the physical system, $\mathcal{S}$ forms an Abelian group and hence can act as a stabilizer set defining subspaces of $\mathcal{H}$. If we describe each of these subspaces by the binary vector, $\vec{e}$, formed from the eigenvalues of the stabilizers, $\mathcal{S}$, then each subspace splits into a tensor product structure

$$\begin{equation} \mathcal{H} = \bigoplus_{\vec{e}} \mathcal{H}_{\mathcal{T}} \otimes \mathcal{H}_{\mathcal{L}}, \end{equation} \tag{ 92 }$$

where elements of $\mathcal{T}$ act only on the subsystem $\mathcal{H}_{\mathcal{T}}$ and the operators $\mathcal{L}$ act only on the subsystem $\mathcal{H}_{\mathcal{L}}$. In the context of storing qubit information, a logical qubit is encoded into the two dimensional subsystem $\mathcal{H}_{\mathcal{L}}$. As the system is already stabilized by operators in $\mathcal{S}$ and the operators in $\mathcal{T}$ act only on the space $\mathcal{H}_{\mathcal{T}}$, qubit information is only altered when operators in the group $\mathcal{L}$ act on the system.

This formal definition of how BS coding works may be more complicated than the standard stabilizer codes shown earlier, but this slightly more complicated coding structure has significant benefits when we consider how error correction is performed.

In general, to perform error correction, each of the stabilizers of the codespace must be checked to determine which eigenvalue changes have occurred due to errors. The stabilizer group, $\mathcal{S}$, consists of qubit operators that scale with the size of the code. In general, for a n₁ × n₂ lattice, the X stabilizers are 2n₁ dimensional and the Z stabilizers are 2n₂ dimensional. If techniques such as Shor's method (section 12) were used, we would need to prepare a large ancilla state to perform fault-tolerant correction, and this is clearly undesirable. This problem can be mitigated due to the gauge structure of these codes [AC07].

Each of the stabilizers in $\mathcal{S}$ is simply the product of certain elements from $\mathcal{T}$, for example,

$$\begin{eqnarray} &&X_{1,1}X_{1,2}X_{1,3}X_{2,1}X_{2,2}X_{2,3} \in \mathcal{S} \\ &&\quad = ( X_{1,1}X_{2,1} ) . (X_{1,2}X_{2,2}).(X_{1,3}X_{2,3}) \in \mathcal{T}. \end{eqnarray} \tag{ 93 }$$

Therefore if we check the eigenvalues of the three, 2-qubit operators from $\mathcal{T}$ we are able to calculate what the eigenvalue is for the six-dimensional stabilizer. This decomposition of the stabilizer set for the code can only occur since the decomposition is in terms of operators from $\mathcal{T}$ which, when measured, has no effect on the logical information encoded within the system. In fact, when error correction is performed, the gauge state of the system will almost always change based on the order in which the eigenvalues of the gauge operators are checked.

This exploitation of the gauge properties of subsystem coding is extremely beneficial for the design of fault-tolerant correction circuits. As the stabilizer operators can now be decomposed into multiple two-dimensional operators, fault-tolerant circuits for error correction do not require any encoded ancilla states. Furthermore, even if we decide to scale the code-space to correct more errors (increasing the lattice size representing the code), we do not require measuring operators with higher dimensionality. Figure 19 taken from [AC07] illustrates the fault-tolerant circuit constructions for Bacon–Shor subsystem codes. As each ancilla qubit is only coupled to two data qubits, no further circuit constructions are required to ensure fault-tolerance¹³. The measurement results from these two-dimensional parity checks are then combined to calculate the parity of the higher dimensional stabilizer of the subsystem code.

Zoom In Zoom Out Reset image size

A second benefit to utilizing subsystem codes is the ability to construct fault-tolerant circuits to perform dynamical code switching. Dynamical code switching is a technique that could be utilized when noise sources are highly biased. In many systems the physical mechanisms which lead to errors are not symmetric in X and Z. For example, simple Markovian dephasing introduces only Z errors into the system and in all circumstances is the more dominant error channel.

One technique is to use concatenation in a clever way. The QEC codes we have largely examined in this review are symmetric in the X and Z sector. The 5-, 7- and 9-qubit codes correct for one X error and one Z error. Aliferis and Preskill considered a concatenated code, where the lower level code is a simple n qubit repetition code (section 4) that only corrected for Z errors [AP08]. By utilizing this lower level code, they symmeterize the Z and X noise (the size of the n qubit code is determined by the level of asymmetry in the physical noise). The subsequent levels are standard QEC codes, but it now operates at the next encoded level which will operate with symmetrical rates for logical X and Z errors. By utilising the simpler n-qubit repetition code at the lower level, qubit resources are reduced, compared to using a symmetric code at every level. This work was extended and adapted to a realistic model in superconducting systems [ABD⁺09].

Asymmetric coding may also be required if the noise acting on a quantum computer changes over the course of its operation. In this case it may be required to switch from a symmetric code to an asymmetric code, dynamically. Naively, this can be done by simply decoding all qubits and then re-encoding them with the new code. However, this procedure would not be fault-tolerant, as any error that occurs to the system when it is decoded will propagate through to the new encoded state. A second technique would be to encode the system with an asymmetric code at the next level of concatenation and then decode the lower level. However, when utilizing the BS codes, we can perform this code switching in a different way. As noted before, the $\mathcal{C}(n_1,n_2)$ code corrects for ⌊(n₁−1)/2⌋ X errors and ⌊(n₁−1)/2⌋ Z errors. The ability to convert between two codes, $\mathcal{C}(n_1,n_2)$ and $\mathcal{C}(n_1',n_2')$, in a fault-tolerant manner would allow for us to dynamically change the strength (or asymmetry) of the error correction whenever noise rates fluctuate in the computer. It was shown in [SEDH08] how such switching can be achieved, allowing for the fault-tolerant conversion between arbitrary sized QEC codes.

A conceptually similar (but technically distinct) coding technique to the Bacon–Shor subsystem codes is the idea of topological error correction, first introduced with the Toric code of Kitaev in 1997 [Kit97]. Topological coding is similar to subsystem codes in that the code structure is defined on a lattice (which, in general, can be of dimension ⩾ 2) and the scaling of the code to correct more errors is conceptually straightforward. However, in topological coding schemes the protection afforded to logical information relies on the unlikely application of error chains which define non-trivial topological paths over the code surface.

Topological error correction is a complicated area of QEC and fault-tolerance and any attempt to fairly summarize the field is not possible within this review. In brief, there are two ways of approaching these schemes. The first is simply to treat topological codes as a class of stabilizer codes over a qubit system. This approach is more amenable to current information technologies and is being adapted to methods in cluster state computing [RHG07, FG09], optics [DFS⁺09, DMN11], ion-traps [SJ09] and superconducting systems [IFI⁺02]. The second approach is to construct a physical Hamiltonian model based on the structure of the topological code or choose systems which appear to exhibit topological order. This leads to the more complicated field on anyonic quantum computation [Kit97]. For example, the coding structure of the Toric code [Kit97] can be treated as a physical Hamiltonian system, with the ground state corresponding to the logical states of the code (in the case of the Torus it is a 4-fold degenerate ground state corresponding to two encoded qubits). Excitations from the ground state of this Hamiltonian correspond to the creation of anyonic quasi-particles and are energetically unfavourable (since their physical Hamiltonian symmetries reflect the coding structure imposed).

This and other models of anyonic computation utilise quasi-particles that exhibit fractional quantum statistics (they acquire fractional phase shifts when their positions are exchanged twice with other anyons, in contrast to bosons or fermions which always acquire ±1 phase shifts). The unique properties of anyonic systems therefore allow for natural, robust, error protection. However, the major issue with this model is that it relies on quasi-particle excitations that do not, in general, arise naturally. Although certain physical systems have been shown to exhibit anyonic properties, most notably in the fractional quantum Hall effect [NSS⁺08]. However, it is a daunting task to both manufacture a reliable anyonic system and to reliably design and construct a large-scale computing system. Note: Recently it has been shown that anyonic models based on the 2D codes illustrated in this section do not exhibit self-correcting properties [KC08, BT09]. Higher dimensional topological coding models, currently a minimum of 4D, are actually required to implement self-correcting quantum memories [AHHH10].

As there are several extremely good discussions of both anyonic [NSS⁺08] and non-anyonic topological computing [DKLP02, FSG09, FG09], we will not review any of the anyonic methods for topological computing and simply provide a brief example of one topological coding scheme, namely the surface code [BK01, DKLP02, FSG09]. The surface code for QEC is a desirable error correction model for several reasons. As it is defined over a two-dimensional lattice of qubits it can be implemented on architectures that only allow for the coupling of nearest neighbour qubits (rather than the arbitrary long distance coupling of qubits in separate regions of the computer). The surface code also exhibits one of the highest fault-tolerant thresholds of any QEC scheme; recent simulations estimate a threshold approaching 1% [RHG07, WFSH10]. Finally, the surface code has been analysed with respect to loss errors, showing a high tolerance when such errors are heralded [SBD09]. This subfield of error correction has been heavily researched in recent years. Methods in statistical physics are now routinely utilized to help calculate fault-tolerant thresholds [BMD08, KBMD09, BAO⁺12, ABKMD12], more advanced coding models and methods for computing with these models are under investigation [BMD07b,BMD07a,KBAMD10, Bom11, Fow12]. This section will present a basic introduction, hopefully readers will feel more comfortable studying these advanced techniques afterwards.

The surface code, as with subsystem codes, is a stabilizer code defined over a two-dimensional qubit lattice, as figure 20 illustrates. We identify each edge of the 2D lattice with a physical qubit. The stabilizer set consists of two types of operators. The first is the set of Z^⊗4 operators which circle every lattice face (or plaquette). The second is the set of X^⊗4 operators which encircle every vertex of the lattice. The stabilizer set is consequently generated by the operators,

$$\begin{equation} A_p = \bigotimes_{j \in b(p)} Z_j, \tqs B_v = \bigotimes_{j \in s(v)} X_j, \end{equation} \tag{ 94 }$$

where b(p) is the four qubits surrounding a plaquette and s(v) is the four qubits surrounding each vertex in the lattice and identity operators on the other qubits are implied. First note that all of these operators commute as any plaquette and vertex stabilizer will share either zero or two qubits. If the lattice is not periodic in either dimension, this stabilizer set completely specifies one unique state, i.e. for a N × N lattice there are 2N² qubits and 2N² stabilizer generators. Hence this stabilizer set defines a unique multi-qubit entangled state which is generally referred to as a 'clean' surface. Detailing exactly how this surface can be utilized to perform robust quantum computation is far outside the scope of this review and there are several papers to which such a discussion can be referred [RH07, RHG07, FSG09, FG09]. Instead, we can quite adequately show how robust error correction is possible by simply examining how a 'clean' surface can be maintained in the presence of errors. The X and Z stabilizer sets, A_p and B_v, define two equivalent 2D lattices which are interlaced, as figure 21 illustrates. If the total 2D lattice is shifted along the diagonal by half a cell then the operators B_v are now arranged around a plaquette and the operators A_p are arranged around a lattice vertex. Since protection against X errors is achieved by detecting eigenvalue flips of Z stabilizers and vice versa, these two interlaced lattices correspond to error correction against X and Z errors respectively. Therefore we can quite happily restrict our discussion to one possible error channel, for example correcting X errors (since the correction for Z errors proceeds identically when considering the stabilizers B_v instead of A_p).

Zoom In Zoom Out Reset image size

Zoom In Zoom Out Reset image size

Figure 22(a) illustrates the effect a single X error has on a pair of adjacent plaquettes. Since X and Z anti-commute, a single bit-flip error on one qubit in the surface will flip the eigenvalue of the Z^⊗4 stabilizers on the two plaquettes adjacent to the respective qubit. As single qubit errors act to flip the eigenvalue of adjacent plaquette stabilizers we examine how chains of errors affect the surface. Figures 22(b) and (c) examine two longer chains of errors. As you can see, if multiple errors occur, only the eigenvalues of the stabilizers associated with the ends of the error chains flip. Each plaquette along the chain will always have two X errors occurring on different boundaries and consequently the eigenvalue of the Z^⊗4 stabilizer around these plaquettes will flip twice.

Zoom In Zoom Out Reset image size

If we now consider an additional ancilla qubit which sits in the centre of each plaquette and can couple to the four surrounding qubits, we can check the parity by running the simple circuit shown in figure 23. If we assume that we initially prepare a perfect 'clean' surface we then, at some later time, check the parity of every plaquette over the surface. If X errors have occurred on a certain subset of qubits, the parity associated with the endpoints of error chains will have flipped. We now take this two-dimensional classical data tree of eigenvalue flips and pair them up into the most likely set of error chains. Since it is assumed that the probability of error on any individual qubit is low, the most likely set of errors which reflects the eigenvalue changes observed is the minimum weight set (i.e. connect up all plaquettes where eigenvalues have changed into pairs such that the total length of all connections is minimized). This classical data processing is quite common in computer science and minimum weight matching algorithms such as the Blossom package [CR99, Kol09] have a running time polynomial in the total number of data points in the classical set. Once this minimal matching is achieved, we can identify the likely error chains corresponding to the end points and correction can be applied accordingly.

Zoom In Zoom Out Reset image size

The failure of this code is therefore dictated by error chains that cannot be detected through changes in plaquette eigenvalues. If you examine figure 24, we consider an error chain that connects one edge of the surface lattice to another. In this case every plaquette has two associated qubits that have experienced a bit flip and no eigenvalues in the surface have changed. Since we have assumed that we are only wishing to maintain a 'clean' surface, these error chains have no effect, but when one considers the case of storing information in the lattice, these types of error chains correspond to logical errors on the qubit [BK98, FSG09]. Hence undetectable errors are chains which connect boundaries of the surface to other boundaries (in the case of information processing, qubits are artificial boundaries within the larger lattice surface). It should be stressed that this is a simplified description of the full protocol, but it does encapsulate the basic idea. The important thing to realize is that the failure rate of the error correction procedure is suppressed, exponentially with the size of the lattice. If we consider an error model where each qubit experiences a bit flip, independently, with probability p, then an error chain of one occurs with probability p, error chains of weight two occur with probability O(p²), chains of three O(p³), etc. If we have an N × N lattice and we extend the surface by one plaquette in each dimension, then the probability of having an error chain connecting two boundaries will drop by a factor of p (one extra qubit has to experience an error)¹⁴. Extending an N × N lattice by one plaquette in each dimension requires O(N) extra qubits, hence this type of error correcting code suppresses the probability of having undetectable errors exponentially with a qubit resource cost which grows linearly.

Zoom In Zoom Out Reset image size

As we showed in section 10, standard concatenated coding techniques allow for an error rate suppression which scales with the concatenation level as a double exponential while the resource increase scales exponentially. For the surface code, the error rate suppression scales exponentially while the resource increase scales linearly. While these scaling relations might be mathematically equivalent, the surface code offers much more flexibility at the architectural level. Being able to increase the error protection in the computer with only a linear change in the number of physical qubits is far more beneficial than using an exponential increase in resources when utilizing concatenated correction. Specifically, consider the case where an error protected computer is operating at a logical error rate which is just above what is required for an algorithm. If concatenated error correction is employed, then adding another layer of correction will not only increase the number of qubits by an exponential amount, but it will also drop the effective logical error rate far below what is actually required. In contrast, if surface codes are employed, we increase the qubit resources by a linear factor and drop the logical error rate sufficiently for successful application of the algorithm.

We now leave the discussion regarding topological correction models. We emphasize again that this was a very broad overview of the general concept of topological codes. There are many details and subtleties that we have deliberately left out of this discussion and we urge the reader, if interested, to refer to the referenced articles for a more thorough treatment of this topic.