Quantum Error Correction for Beginners

Simon J. Devitt∗ and Kae Nemoto

National Institute of Informatics, 2-1-2 Hitotsubashi, Chiyoda-ku, Tokyo 101-8340, Japan

William J. Munro

NTT Basic Research Laboratories, NTT Corporation, 3-1 Morinosato-Wakamiya, Atsugi, Kanagawa 243-0198,Japan andNational Institute of Informatics, 2-1-2 Hitotsubashi, Chiyoda-ku, Tokyo 101-8340, Japan

(Dated: September 8, 2011)

Quantum error correction (QEC) and fault-tolerant quantum computation represent one of themost vital theoretical aspect of quantum information processing. It was well known from theearly developments of this exciting field that the fragility of coherent quantum systems would bea catastrophic obstacle to the development of large scale quantum computers. The introduction ofquantum error correction in 1995 showed that active techniques could be employed to mitigate thisfatal problem. However, quantum error correction and fault-tolerant computation is now a muchlarger field and many new codes, techniques, and methodologies have been developed to implementerror correction for large scale quantum algorithms. In response, we have attempted to summarizethe basic aspects of quantum error correction and fault-tolerance, not as a detailed guide, butrather as a basic introduction. This development in this area has been so pronounced that manyin the field of quantum information, specifically researchers who are new to quantum informationor people focused on the many other important issues in quantum computation, have found itdifficult to keep up with the general formalisms and methodologies employed in this area. Ratherthan introducing these concepts from a rigorous mathematical and computer science framework,we instead examine error correction and fault-tolerance largely through detailed examples, whichare more relevant to experimentalists today and in the near future.

PACS numbers: 03.67.Lx, 03.67.Pp

Contents

I. Introduction 2

II. Preliminaries 3A. Basic structure of the qubit 3B. Some general requirements of quantum error

correction 3

III. Quantum errors: Cause and effect 4A. Coherent quantum errors: Gates which are

incorrectly applied 4B. Environmental decoherence 5C. Simple models of loss, leakage, measurement and

initialization 5

IV. The 3-qubit code: a good starting point forquantum error correction 7

V. The 9-qubit code: The first full quantum code 10

VI. Quantum error detection 10

VII. Stabiliser formalism 11

VIII. Quantum error correction with stabiliser codes 13A. State preparation 14B. Error correction 15

IX. Digitization of quantum errors 16

∗electronic address: devitt@nii.ac.jp

A. Systematic gate errors 16

B. Environmental decoherence 17

C. More general mappings 18

X. Fault-tolerant quantum error correction and thethreshold theorem 18

A. Error propagation 19

B. Fault-tolerance 20

C. Threshold theorem 20

XI. Fault-tolerant operations on encoded data 21

A. Single qubit operations 21

B. Two-qubit gate 23

XII. Fault-tolerant circuit design for logical statepreparation 24

XIII. Loss protection 25

XIV. Some modern developments in quantum errorcorrection 28

A. Subsystem codes: Bacon-Shor codes 28

B. Topological codes 31

XV. Conclusions and future outlook 34

XVI. Acknowledgments 35

References 35

arX

iv:0

905.

2794

v3 [

quan

t-ph

] 7

Sep

201

1

2

I. INTRODUCTION

The micro-computer revolution of the late 20th centuryhas arguably been of greater impact to the world thanany other technological revolution in history. The adventof transistors, integrated circuits, and the modern micro-processor has spawned literally hundreds of devices frompocket calculators to the iPod, all now integrated throughan extensive worldwide communications system. How-ever, as we enter the 21st century ever increasing compu-tational power is driving us quickly to the realm wherequantum physics dominates. The component size of indi-vidual transistors on modern microprocessors are becom-ing so small that quantum effects will soon begin to domi-nate. Unfortunately, quantum mechanical behaviour willtend to result in unpredictable and unwanted operationin classical microprocessor designs. We therefore havetwo choices: keep trying to suppressing quantum effectsin classically fabricated electronics or move to the field ofquantum information processing (QIP) where we exploitthem. This leads to a paradigm shift in the way we viewand process information and has commanded consider-able interest from physicists, engineers, computer sci-entists and mathematicians. The counter-intuitive andstrange rules of quantum physics offers enormous possi-bilities for information processing and the developmentof a large scale quantum computer is the holy grail formany researchers worldwide.

While the advent of Shor’s algorithm (Sho97) certainlyspawned great interest in quantum information process-ing, demonstrating that quantum algorithms could befar more efficient than those used in classical computing,there was a great deal of debate surrounding the practi-cality of building a large scale, controllable, quantum sys-tem. It was well known even before the introduction ofquantum information that coherent quantum states wereextremely fragile and many believed that to maintainlarge, multi-qubit, coherent quantum states for a longenough time to complete any quantum algorithm was un-realistic (Unr95). Additionally, classical error correctiontechniques are intrinsically based on a digital framework,unlike quantum computing where the readout of qubitsis digital but actual manipulations are analogue. There-fore, how can we adapt the vast knowledge gained fromclassical coding theory to the quantum regime?

Starting in 1995, several papers appeared, in rapid suc-cession, proposing codes which were appropriate to per-form error correction on quantum data (Sho95; Ste96a;CS96; LMPZ96; BSW96). This was a key theoreti-cal development needed to convince the general commu-nity that quantum computation was indeed a possibility.Since this initial introduction, the progress in this fieldhas been extensive.

Initial research on error correction focused heavilyon developing quantum codes (Ste96c; Ste96b; Got96;PVK97; KL97; Kni96), introducing a more rigorous the-oretical framework for the structure, properties and op-eration of QEC (BSW96; KL00; CRSS98; Got97; CG97;

KLV00). Additionally, the introduction of concepts suchas fault-tolerant quantum computation (Sho96; DS96;Got98; KLZ98; Got00) leading directly to the thresholdtheorem for concatenated QEC (KLZ96; ABO97). Inmore recent years, QEC protocols have been developedfor various systems, such as, continuous variables (LS98;Bra98; vL08; ATK+09), ion-traps and other systems con-taining motional degrees of freedom (ST00), adiabaticcomputation (JFS06) and globally controlled quantumcomputers (BBK03). Work also continues on not onlydeveloping better (and in some ways, more technologi-cally useful) protocols such as subsystem codes (KLP05;KLPL06; Bac06) and topological codes (Kit97; DKLP02;BMD06; BMD07b; BMD07a; RHG07; FSG09) but alsoadvanced techniques to implement error correction in afault-tolerant manner (Ste97a; Ste02; DA07; Kni05).

Along with QEC, other methods of protecting quan-tum information were also developed. These other tech-niques would technically be placed in a separate categoryof error suppression rather than error correction. Themost well known techniques of error suppression are pro-tocols such as decoherence free subspaces (DFS) (PSE96;DG97; LCW98; DG98b; ZR97b; ZR97a; DG98a; LW03).DFS protocols are passive, encoding information in a sub-space which is invariant under the dynamics that gener-ate errors. Active methods for error suppression includeapplying repeated rotations to qubits such that these ro-tations, combined with the natural dynamics that induceerrors partially cancel. These methods were initially re-ferred to as Bang-Bang control (VL98; VT99; Zan99) anddeveloped primarily for NMR systems. In recent yearsthese techniques have been further generalized and opti-mized for use in essentially all quantum information pro-cessing systems (VKL99; FLP04; VK03; VK05; KL05;Uhr07). These more advanced techniques are now rou-tinely categorized as dynamical decoupling protocols. Aswith QEC, this field is vast, incorporating well estab-lished ideas from quantum control to create specially de-signed control sequences to suppress errors before moreresource intensive encoding is applied.

This review deals exclusively with the concepts ofQEC and fault-tolerant quantum computation. Manypapers have reviewed error correction and fault-tolerance (Got97; NC00; Got02; KLA+02; Ste01;Got09), however to cater for a large audience, we attemptto describe QEC and fault-tolerance in a more basic man-ner, largely through examples. Instead of providing amore rigorous review of error correction, we instead fo-cus on more practical issues involved when working withthese ideas. For those who have recently begun inves-tigating quantum information processing or those whoare focused on other important theoretical and/or exper-imental aspects related to quantum computing, searchingthrough this enormous collection of work is daunting es-pecially if a basic working knowledge of QEC is all thatis required. This review of the basic aspects of QECand fault-tolerance is designed to allow those with lit-tle knowledge of the field to quickly become accustomed

3

to the various techniques and tricks that are commonlyused. The examples in this review are selected due totheir relative simplicity. For individuals seriously inter-ested in examining new ideas for QEC and fault-tolerantcomputation we strongly advise that the references citedthroughout are consulted.

We begin the discussion in section II where we describesome preliminary concepts on the required properties ofany quantum error correcting protocol. In section III wereview some basic noise models from the context of howthey influence quantum algorithms. Section IV intro-duces quantum error correction through the traditionalexample of the 3-qubit code, illustrating the circuits usedfor encoding and correction and why the principle ofredundant encoding suppresses the failure of encodedqubits. Sections V and VI introduce the first examplesof complete quantum codes, Shor’s 9-qubit code and a 4-qubit error detection code. Sections VII and VIII intro-duces the stabiliser formalism, demonstrating how QECcircuits are synthesized once the structure of the code isknown. In section IX we briefly return to noise modelsand relate the abstract analysis of QEC, where errors areassumed to be discrete and probabilistic, to some of thephysical mechanisms which can cause errors. Sections Xand XI introduce the concept of fault-tolerant error cor-rection, the threshold theorem and how logical gate op-erations can be applied directly to encoded data. Wethen move onto circuit synthesis in section XII, present-ing a fault-tolerant circuit design for state preparationusing the 7-qubit Steane code as a representative exam-ple. Finally, in section XIV, we review specific codes forqubit loss and examine two more modern techniques forerror correction. We briefly examine quantum subsystemcodes (KLP05; KLPL06; Bac06) and topological surfacecodes (DKLP02; FSG09) due to both their theoreticalelegance and their increasing relevance in quantum ar-chitecture designs (IFI+02; DFS+09; SJ09; MLFY10).

II. PRELIMINARIES

Before discussing quantum errors and how they canbe corrected, we first introduce the basics of qubits andquantum gates. We assume a basic working knowledgewith quantum information (EJ96; NC00) and this briefdiscussion is used simply to define our notation for theremainder of this review.

A. Basic structure of the qubit

The fundamental unit of quantum information is thequbit. Unlike the classical bit, the qubit can exist incoherent superpositions of its two states, denoted as |0〉and |1〉. These basis states can be, for example, photonicpolarization, atomic spin states, electronic states of anion or charge states of superconducting systems. An ar-bitrary state of an individual qubit, |φ〉, can be expressed

as,

|φ〉 = α |0〉+ β |1〉 (1)

where |0〉 and |1〉 are the two orthonormal basis statesof the qubit and |α|2 + |β|2 = 1. Quantum gate opera-tions are represented by unitary operations acting on theHilbert space of a collection of qubits. Unlike classicalinformation processing, conservation of probability forquantum states require that all operations be reversibleand hence unitary.

When describing a quantum gate on an individualqubit, any dynamical operation, G, is a member of theunitary group U(2), which consists of all 2 × 2 matriceswhere G† = G−1. Up to a global (and unphysical) phasefactor, any single qubit operation can be expressed as alinear combination of the generators of SU(2) as,

G = cIσI + cxσx + cyσy + czσz (2)

where,

σx =

(0 11 0

), σy =

(0 −ii 0

), σz =

(1 00 −1

), (3)

are the Pauli matrices, σI is the 2 × 2 identity matrix,cI is a real number, and (cx, cy, cz) are complex numberssatisfying,

|cI |2 + |cx|2 + |cy|2 + |cz|2 = 1,

<(cIc∗x) + =(cyc

∗z) = 0,

<(cIc∗y) + =(cxc

∗z) = 0,

<(cIc∗z) + =(cxc

∗y) = 0.

(4)

Here < and = are the real and imaginary componentsrespectively.

B. Some general requirements of quantum error correction

Although the field of QEC is largely based on clas-sical coding theory, there are several issues that need tobe considered when transferring classical error correctiontechniques to the quantum regime.

First, coding based on data-copying, which is exten-sively used in classical error correction cannot be useddue to the no-cloning theorem of quantum mechan-ics (WZ82). This result implies that there exists no trans-formation resulting in the following mapping,

U(|φ〉 ⊗ |ψ〉) = |φ〉 ⊗ |φ〉 ∀ |φ〉 . (5)

i.e. it is impossible to perfectly copy an unknown quan-tum state. This means that quantum data cannot beprotected from errors by simply making multiple copies.Secondly, direct measurement cannot be used to effec-tively protect against errors, since this will act to destroyany quantum superposition that is being used for com-putation. Error correction protocols must therefore be

4

employed, which can detect and correct errors withoutdetermining any information regarding the qubit state.Finally, unlike classical information, qubits are suscepti-ble to both traditional bit errors |0〉 ↔ |1〉, and also phaseerrors |0〉 ↔ |0〉, |1〉 ↔ − |1〉. Hence any error correctionprocedure needs to be able to simultaneously correct forboth.

At its most basic level, QEC utilizes the idea of redun-dant encoding. This is where the total size of the Hilbertspace is expanded beyond what is needed to store a sin-gle qubit of information. This way, errors on individualqubits are mapped to large set of mutually orthogonalsubspaces, the size of which is determined by the num-ber of qubits utilized in the code. Finally, the error cor-rection protocol cannot allow us to gain information re-garding the coefficients, α and β of the encoded state; asdoing so would collapse the system.

III. QUANTUM ERRORS: CAUSE AND EFFECT

Before we begin discussing the details of QEC, we firstexamine some of the common sources of errors in quan-tum information processing and contextualize what theyimply for computation. We will consider several impor-tant sources of errors and how they influence two trivial,single qubit quantum algorithms.

The first algorithm is a computation consisting of asingle qubit, initialized in the |0〉 state undergoing Nidentity operations. If this algorithm is performed per-fectly the final state is,

|ψ〉final =

N∏i

Ii |0〉 = |0〉 , (6)

where I ≡ σI is the identity gate. Measurement of thequbit in the |0〉, |1〉 basis will consequently yield the result0 with a probability of unity.

The second illustration is an algorithm of three gates,

|ψ〉final = HIH |0〉 = HI1√2

(|0〉+ |1〉)

= H1√2

(|0〉+ |1〉)

= |0〉 .

(7)

This algorithm will ideally yield a result |0〉 with prob-ability of 1 when measured in the |0〉, |1〉 basis. Thisalgorithm implements two H ≡ Hadamard operationsseparated by a wait stage, represented by the Identitygate.

We examine, independently, several common sourcesof error from the effect they have on these two quan-tum algorithms. Hopefully, this introductory section willshow that while quantum errors are complicated physi-cal effects, in QIP the relevant measure is the theoreticalsuccess probability of a given quantum algorithm.

Errors that exist on any quantum system are highlydependent on the specific physical mechanisms that gov-ern the system. The situations that follow are only basicillustrative examples which can often arise in discussionsrelated to errors and QEC. It is important to stress thatthe types of errors and the way in which they are ana-lyzed needs to be considered in the context of the physicalsystem under consideration.

A. Coherent quantum errors: Gates which are incorrectlyapplied

The first possible source of error is coherent, system-atic control errors. This type of error is typically asso-ciated with incorrect knowledge of the system dynam-ics. Namely, otherwise perfect control assuming a sys-tem governed by a Hamiltonian H ′ when the actual sys-tem dynamics is governed by H. As qubit systems mustbe characterized prior to being used (PCZ97; CSG+05),finite experimental resolution with these processes willlead to coherent control errors. As these errors are co-herent inaccuracies applied to the qubit, they can be mit-igated using coherent techniques such as composite pulsesequences (LF79; Lev86; BHC04; Jon09). Other controlerrors (e.g. arising from fluctuations in control fields)are not coherent processes and are dealt with in a similarway to environmental coupling described further on.

As this source of error is coherent and systematic itcauses you to apply the same, undesired gate operationand can be analyzed without moving to the density ma-trix formalism. With respect to the first of our algo-rithms, we are able to model this several different ways.To keep things simple, we assume that incorrect charac-terization of the control dynamics leads to a gate whichis not σI , but instead introduces a small rotation aroundthe X-axis of the Bloch sphere. This results in the state,

|ψ〉final =

N∏eiεσx |0〉 = cos(Nε) |0〉+ i sin(Nε) |1〉 . (8)

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

P (|0〉) = cos2(Nε) ≈ 1− (Nε)2,

P (|1〉) = sin2(Nε) ≈ (Nε)2.(9)

Hence, the probability of error in this trivial quantumalgorithm is given by perror ≈ (Nε)2, which will be smallgiven that Nε� 1. The systematic error in this system isquadratic in both the small systematic over rotation andthe total number of applied identity operations. This isexpected as this rotational error always acts in the samedirection every time it is applied.

5

B. Environmental decoherence

Environmental decoherence is another importantsource of errors in quantum systems. We will take asimple decoherence model and examine how our secondalgorithm behaves. Later in section IX we will illustratea more complicated decoherence model that arises fromstandard mechanisms.

Consider a very simple environment, which is anothertwo level quantum system. This environment has twobasis states, |e0〉 and |e1〉, that satisfy the completenessrelations,

〈ei| ej〉 = δij , |e0〉 〈e0|+ |e1〉 〈e1| = I. (10)

We will also assume that the environment couples tothe 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 happensto the environment. Finally, this model assumes the sys-tem/environment interaction only occurs during the waitstage of the algorithm (while the Identity gate is beingapplied). As with the first algorithm we should measurethe state |0〉 with probability one. The reason for utiliz-ing the second of our algorithms in this example is thatthis specific decoherence model acts to reduce coherencebetween the |0〉 and |1〉 states. Therefore, we requirea coherent superposition to observe any effect from theenvironmental coupling. We assume the environment isinitialized in the state, |E〉 = |e0〉, and then coupled tothe system,

HIH |0〉 |E〉 =1

2(|0〉+ |1〉) |e0〉+

1

2(|0〉 − |1〉) |e1〉 (11)

As we are considering environmental decoherence, purestates will be transformed into classical mixtures, hencewe now move into the density matrix representation forthe state HIH |0〉 |E〉,

ρf =1

4(|0〉 〈0|+ |0〉 〈1|+ |1〉 〈0|+ |1〉 〈1|) |e0〉 〈e0|

+1

4(|0〉 〈0| − |0〉 〈1| − |1〉 〈0|+ |1〉 〈1|) |e1〉 〈e1|

+1

4(|0〉 〈0| − |0〉 〈1|+ |1〉 〈0| − |1〉 〈1|) |e0〉 〈e1|

+1

4(|0〉 〈0|+ |0〉 〈1| − |1〉 〈0| − |1〉 〈1|) |e1〉 〈e0| .

(12)

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

TrE(ρf ) =1

4(|0〉 〈0|+ |0〉 〈1|+ |1〉 〈0|+ |1〉 〈1|)

+1

4(|0〉 〈0| − |0〉 〈1| − |1〉 〈0|+ |1〉 〈1|)

=1

2(|0〉 〈0|+ |1〉 〈1|).

(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 andis consequently a classical system. The coupling to theenvironment removed all the coherences between the |0〉and |1〉 states and the second Hadamard transform, in-

tended to rotate (|0〉 + |1〉)/√

2 → |0〉, has no effect onthe qubit state.

As we assumed that the system/environment couplingduring the wait stage causes the environmental degree offreedom to “flip” (when the qubit is in the |1〉 state) thisdecoherence model implicitly incorporates a temporal ef-fect. The temporal interval of the identity gate in theabove algorithm is long enough to enact the controlled-flip operation. If we assumed a controlled rotation that isnot a full flip on the environment, the final mixture willnot be 50/50. Instead there would be a residual coherencebetween the qubit states and an increased probability ofour algorithm returning a |0〉. Section IX revisits the de-coherence model and illustrates how time-dependence isexplicitly incorporated.

C. Simple models of loss, leakage, measurement andinitialization

Other sources of error such as qubit initialization, mea-surement errors, qubit loss and qubit leakage can be mod-eled in a very similar manner. As with coherent con-trol errors and environmental decoherence, the specificsof other error channels can be modeled in a coherentor incoherent manner, depending on the physical mech-anisms. The examples shown below are commonplacewithin QEC analysis and adequately apply to a largenumber of systems.

Measurement errors can be modeled in the same wayas environmental decoherence, acting incoherently on thesystem. Measurement errors can be described in twoslightly different ways. The first it to use the followingpositive operator value measures (POVM’s),

F0 = (1− pM ) |0〉 〈0|+ pM |1〉 〈1| ,F1 = (1− pM ) |1〉 〈1|+ pM |0〉 〈0| ,

(14)

where pM is the probability of measurement error. Theseare not measurement projectors as F 2

0 6= F0 and F 21 6= F1.

The second method is to apply the following mapping tothe qubit,

ρ→ ρ′ = (1− pM )ρ+ pMXρX (15)

followed by a perfect measurement in the (|0〉 , |1〉) basis.These two models give exactly the same probabilities foreach outcome. Defining A0 = |0〉 〈0| and A1 = |1〉 〈1| asthe measurement projectors onto the (|0〉 , |1〉) basis wefind,

Tr(F0ρ) = (1− pM )Tr(A0ρ) + pMTr(A1ρ),

Tr(F1ρ) = (1− pM )Tr(A1ρ) + pMTr(A0ρ),(16)

6

Tr(A0ρ′) = (1− pM )Tr(A0ρ) + pMTr(XA0Xρ)

= (1− pM )Tr(A0ρ) + pMTr(A1ρ),

Tr(A1ρ′) = (1− pM )Tr(A1ρ) + pMTr(XA1Xρ)

= (1− pM )Tr(A1ρ) + pMTr(A0ρ).

(17)

Hence, either method will result in the same probabilitiesfor a given value of pM . The difference between these twomodels is the state the measured qubit is projected to.

When using the POVM’s in Eq.(14), the collapsedstate of the qubit is given by,

ρ→ MiρM†i

Tr(Fiρ)i = 0, 1, (18)

where,

M0 =√

1− pM |0〉 〈0|+√pM |1〉 〈1| ,

M1 =√

1− pM |1〉 〈1|+√pM |0〉 〈0| .

(19)

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

1√2

(|0〉+ |1〉) . (20)

Using both models, the probability of measuring |0〉 is1/2 (as the above state is invariant under a bit-flip er-ror). If the POVM model is used (using the F0 and M0

operators), the state after measurement is,√(1− pm) |0〉+

√pm |1〉 . (21)

The collapsed state, after measurement, is a superposi-tion of |0〉 and |1〉, with amplitudes related to pm. If weuse the second model (using the projector A0), the stateafter measurement is simply |0〉. As measurement is gen-erally followed by either discarding the qubit or reinitial-izing it in a known state, both models can generally beused interchangeably with no adverse consequences.

Qubit loss is modeled in a slightly different manner.When a qubit is lost, it is effectively removed from thesystem. This channel can be modeled by simply tracingout the lost qubit, Tri(ρ), where i is the index of the lostqubit. This reduces the dimensionality of the qubit spaceby a factor of two.

The loss of the physical object means that it cannot bedirectly measured or coupled to any other ancillary sys-tem. Even though this model of qubit loss (with regardsto the information stored on the qubit) is equivalent toincoherent processes such as environmental coupling, cor-recting this type of error requires additional machineryon top of standard QEC protocols. Standard correctionprotocols can protect against the loss of information ona qubit, provided that the physical object still exists inthe computer. Therefore, an initial non-demolition de-tection must be employed (which determines if the qubit

is actually present without performing a projective mea-surement on the computational state) before standardcorrection can correct the error.

Initialization of the qubit can be modeled either us-ing a coherent systematic or incoherent process. If anincoherent model is employed, initialization can be mod-eled essentially the same way as imperfect measurement.If we have a probability pI of initialization error (wherepI encapsulates the internal mechanisms that introduceerrors) and we initialize the qubit in the |0〉 state, theinitial state of the system is given by the mixture,

ρi = (1− pI) |0〉 〈0|+ pI |1〉 〈1| . (22)

In contrast, we could consider an initialization modelwhich is achieved via a coherent unitary operation wherethe target is the desired initial state. In this case, theinitial state is pure, but contains a non-zero amplitudeof the undesired target, for example,

|ψ〉 = α |0〉+ β |1〉 , (23)

where |α|2 + |β|2 = 1 and |β|2 � 1. The interpretation ofthese two types of initialization models is identical to thecoherent and incoherent models presented. Again, theeffect of these types of errors relates to the probabilitiesof measuring the system in an erred state.

One final type of error that we can briefly mention isqubit leakage. Qubit leakage manifests due to the factthat most systems utilized for qubits do not consist ofjust 2 levels. For example, Fig 1 (from Ref. (Ste97b))illustrates the energy level structure for a 43Ca+ ion uti-lized for ion trap quantum computing. The qubits in thissystem are defined with two electronic states, however thesystem itself contains many more levels (including somewhich are used for qubit readout and initialization). Aswith systematic errors, leakage can occur when impropercontrol is applied to such a system. In the case of ion-traps, qubit transitions are performed by focusing finelytuned lasers resonant on the relevant transitions. If thelaser frequency fluctuates or additional levels are not suf-ficiently detuned from the qubit resonance, the followingtransformation could occur,

U |0〉 = α |0〉+ β |1〉+ γ |2〉 , (24)

where the state |2〉 is a third level, which is now popu-lated due to improper control. The actual effect of thistype of error can manifest in several different ways. Asquantum circuits and algorithms are fundamentally de-signed assuming the computational array is a of 2-levelsystems, the transformation shown in Eq. (24) (whichin this case is operating over a 3-level space) will natu-rally induce unwanted dynamics. Another important im-plication of applying non-qubit operations is how theselevels interact with the environment and hence how de-coherence effects the system. For example, in the abovecase, the unwanted level, |2〉, may be extremely shortlived leading to an emission of a photon and the systemrelaxing back to the ground state. For these reasons,

7

FIG. 1 (from Ref. (Ste97b)) Energy level structure for the43Ca+ investigated by the Oxford ion-trapping group. Thestructure of this ion is clearly not a 2-level quantum system.Hence leakage into non-qubit states is an important factor toconsider.

leakage is one of the most problematic error channels tocorrect using QEC. In general, leakage induced errorsneed to be corrected in a similar manner to loss, whichcan also be thought of as a leakage process into a vac-uum state. Non-demolition techniques are first requiredto determine if the system is still confined to the qubitsubspace (Pre98; GBP97; VWW05) after which standardcorrection protocols can be utilized. Another well knownmethod is to use a complicated pulse sequence which actsto re-focus an improperly confined operation back to thequbit subspace (WBL02; BLWZ05). This can be advan-tageous as it does not require additional qubit resources.

Leakage effects arise from multiple sources, and thebest method for correction is often heavily dependenton the error mechanisms. One example is when inter-nal fluctuations in the system change otherwise perfectqubit dynamics. Unfortunately this leakage source gen-erally cannot be predicted and/or characterized and so

dedicated leakage protection will need to be employed.A second source is imprecise fabrication of an other-wise perfect qubit system. This source of leakage can,in principal, be engineered away, thereby eliminating theneed for specialized leakage correction. In the contextof mass manufacturing of qubit systems, leakage wouldideally be quantified immediately after the fabrication ofa device (DSO+07) to eliminate these systematic leak-age errors. If a particular system is found to be im-properly confined to the qubit subspace, it would simplybe discarded. Employing characterization at this stagecould potentially eliminate the need to implement a largeamount of leakage protection in the computer, shorten-ing gate times and ultimately reducing error rates in thecomputer.

In this section we have presented a very basic set ofexamples to explain some of the ideas of quantum errorsand how they effect the success of a quantum algorithm.Section IX will return to a more realistic set of errormodels. For those interested in a more complete treat-ment of quantum errors we encourage readers to referto (Got97; NC00; Got02; KLA+02; Ste01; Got09).

IV. THE 3-QUBIT CODE: A GOOD STARTING POINTFOR QUANTUM ERROR CORRECTION

The 3-qubit bit-flip code is traditionally used as a basicintroduction to the concept of quantum error correction.It should be emphasized that the 3-qubit code does notrepresent a full quantum code. This is due to the factthat the code cannot simultaneously correct for both bitand phase flips [Sec. IX]. This code is a repetition codeextended by Shor (Sho95) to construct the 9-qubit quan-tum code, demonstrating that QEC was possible.

The 3-qubit code encodes a single logical qubit intothree physical qubits with the property that it can correctfor a single, σx, bit-flip error. The two logical basis states|0〉L and |1〉L are defined as,

|0〉L = |000〉 , |1〉L = |111〉 , (25)

such that an arbitrary single qubit state |ψ〉 = α |0〉+β |1〉is mapped to,

α |0〉+ β |1〉 → α |0〉L + β |1〉L= α |000〉+ β |111〉= |ψ〉L .

(26)

Fig. 2 illustrates the quantum circuit required to encodea single logical qubit via the initialization of two an-cilla qubits and two CNOT gates. The reason that thiscode is able to correct for a single bit-flip error is thebinary distance between the two codeword states. No-tice that three individual bit flips are required to take|0〉L ↔ |1〉L, hence if we assume |ψ〉 = |0〉L, a single bitflip on any qubit leaves the final state closer to |0〉L than|1〉L. The distance between two codeword states, d, de-fines the number of errors that can be corrected, t, as,t = b(d− 1)/2c. In this case, d = 3, hence t = 1.

8

FIG. 2 Quantum Circuit to prepare the |0〉L state for the 3-qubit code where an arbitrary single qubit state, |ψ〉 is coupledto two freshly initialized ancilla qubits via CNOT gates toprepare |ψ〉L.

How are we able to correct errors using this code with-out directly measuring or obtaining information aboutthe logical state? Two additional ancilla qubits areintroduced, which are used to extract syndrome infor-mation (information regarding possible errors) from thedata block without discriminating the exact state of anyqubit. The encoding and correction circuit is illustratedin Fig. 3. Correction proceeds by introducing two ancillaqubits and performing a sequence of CNOT gates, whichchecks the parity of the three qubit data block. For the

M

M

Correct

Error

FIG. 3 Circuit required to encode and correct for a singleσx-error. We assume that after encoding a single bit-flip oc-curs on one of the three qubits (or no error occurs). Twoinitialized ancilla are then coupled to the data block whichonly checks the parity between qubits. These ancilla are thenmeasured, with the measurement result indicating where (orif) an error has occurred, without directly measuring any ofthe data qubits. Using this syndrome information, the errorcan be corrected with a classically controlled σx gate.

sake of simplicity we assume that all gate operations areperfect and the only place where the qubits are suscepti-ble to error is the region between encoding and correction(As illustrated in Fig 3). We will return to this issue insection X when we discuss fault-tolerance. We also as-sume that at most a single, complete bit flip error occurson one of the three data qubits. Table I summarizes thestate of the whole system, for each possible error, justprior to measurement.

For each possible situation, either no error or a singlebit-flip error, the ancilla qubits are flipped to a uniquestate based on the parity of the data block. These qubitsare then measured to obtain the classical syndrome re-

Error Location Final State, |data〉 |ancilla〉No Error α |000〉 |00〉+ β |111〉 |00〉Qubit 1 α |100〉 |11〉+ β |011〉 |11〉Qubit 2 α |010〉 |10〉+ β |101〉 |10〉Qubit 3 α |001〉 |01〉+ β |110〉 |01〉

TABLE I Final state of the five qubit system prior to thesyndrome measurement for no error or a single X error onone of the qubits. The last two qubits represent the stateof the ancilla. Note that each possible error will result in aunique measurement result (syndrome) of the ancilla qubits.This allows for a σx correction gate to be applied to the datablock which is classically controlled from the syndrome result.

sult. The result of the measurement will then dictate ifa correction gate needs to be applied. This is illustratedin Table. II.

Ancilla Measurement Collapsed State Consequence00 α |000〉+ β |111〉 No Error01 α |001〉+ β |110〉 σx on Qubit 310 α |010〉+ β |101〉 σx on Qubit 211 α |100〉+ β |011〉 σx on Qubit 1

TABLE II Ancilla measurements for a single σx error withthe 3-qubit code. Each of the four possible results correspondto either no error or a bit flip on one of the three qubits.

Provided that only a single error has occurred, the datablock is restored. At no point during correction do wegain any information regarding the coefficients α and β,hence superpositions of the computational state will re-main in-tact during correction.

This code will only work if a maximum of one erroroccurs. The 3-qubit code is a d = 3 code, hence if t > 1,then the resulting state becomes “closer” to the wronglogical state. This can be seen in Table. III when track-ing multiple errors through the correction circuit. In

Error Location Final State, |data〉 |ancilla〉 Assumed ErrorQubit 1 & 2 α |110〉 |01〉+ β |001〉 |01〉 σx on Qubit 3Qubit 2 & 3 α |011〉 |11〉+ β |100〉 |11〉 σx on Qubit 1Qubit 1 & 3 α |101〉 |10〉+ β |010〉 |10〉 σx on Qubit 2

Qubit 1, 2 & 3 α |111〉 |00〉+ β |000〉 |00〉 No Error

TABLE III Ambiguity of syndrome results when multiple er-rors occur.

each case, we assume that the total number of errors is> d/2, therefore our correction takes us to the wrong log-ical state. In every case where t > 1 our mis-correctioninduces a logical bit flip, causing the code to fail.

To be absolutely clear on how QEC acts to restore thesystem and protect against errors let us now consider adifferent and slightly more physically realistic example.We will assume that the errors acting on the qubits arecoherent rotations of the form U = exp(iεσx) on each

9

qubit, with ε� 1. We choose coherent rotations so thatwe can remain in the state vector representation. Thisis not a necessary requirement, however more general in-coherent mappings would require us to move to densitymatrices.

We assume that each qubit experiences the same error,hence the error operator acting on the state is,

|ψ〉E = E |ψ〉L ,E = U⊗3 = (cos(ε)σI + i sin(ε)σx)⊗3

= c0σIσIσI

+ c1(σxσIσI + σIσxσI + σIσIσx)

+ c2(σxσxσI + σIσxσx + σxσIσx)

+ c3σxσxσx.

(27)

where,

c0 = cos3(ε),

c1 = i cos2(ε) sin(ε),

c2 = − cos(ε) sin2(ε),

c3 = −i sin3(ε).

(28)

Now let’s examine the transformation that occurs whenwe run the error correction circuit in Fig. 3. This isrepresented via the unitary transformation, UQEC, overboth the data and ancilla qubits,

UQEC(E |ψ〉L |00〉) = c0 |ψ〉L |00〉+ c1σxσIσI |ψ〉L |11〉+ c1σIσxσI |ψ〉L |10〉+ c1σIσIσx |ψ〉L |01〉+ c2σxσxσI |ψ〉L |10〉+ c2σIσxσx |ψ〉L |11〉+ c2σxσIσx |ψ〉L |01〉+ c3σxσxσx |ψ〉L |00〉

(29)

Once again, the ancilla block is measured and the ap-propriate correction operator is applied, yielding the re-sults (up to renormalisation) shown in Table. IV. In each

Ancilla Measurement Collapsed State (with correction)00 c0 |ψ〉L + c3σxσxσx |ψ〉L01 c1 |ψ〉L + c2σxσxσx |ψ〉L10 c1 |ψ〉L + c2σxσxσx |ψ〉L11 c1 |ψ〉L + c2σxσxσx |ψ〉L

TABLE IV Resulting logical state after a round of error cor-rection with the 3-qubit code.

case, after correction (based on the syndrome result), weare left with approximately the same state, a superpo-sition of a “clean state” with the logically flipped state,σxσxσx |ψ〉. Let us now examine in detail the amplitudesnow associated with each term in these states. If we con-sider the unitary U acting on a single, unencoded qubit,

the rotation takes the state |ψ〉 to,

U |ψ〉 = cos(ε) |ψ〉+ i sin(ε)σx |ψ〉 , (30)

Consequently, the fidelity of the single qubit state is,

Funencoded = | 〈ψ|U |ψ〉 |2 = cos2 ε ≈ 1− ε2 (31)

In contrast, the worst case fidelity1 of the encoded qubitstate after a cycle of error correction is,

Fno error detected =|c0|2

|c0|2 + |c3|2

=cos6(ε)

cos6(ε) + sin6(ε)

≈ 1− ε6,

(32)

with probability 1− 3ε2 +O(ε4) and

Ferror detected =|c1|2

|c1|2 + |c2|2

=cos4(ε) sin2(ε)

cos4(ε) sin2(ε) + sin4(ε) cos2(ε)

≈ 1− ε2,

(33)

with probability 3ε2 +O(ε4). This is the general idea ofhow QEC suppresses errors at the logical level. Duringa round of error correction, if no error is detected, theerror on the resulting state is suppressed from O(ε2) toO(ε6). If a single error is detected, the fidelity of the re-sulting state remains the same. As the 3-qubit code is asingle error correcting code, if one error has already beencorrected then the failure rate of the logical qubit is con-ditional on experiencing one further error (which will beproportional to ε2). As ε� 1 the majority of correctioncycles will detect no error and the fidelity of the resultingencoded state is higher than when unencoded.

It should be stressed that no error correctionscheme will, in general, restore a corrupted stateto the original logical state. The resulting state willgenerally contain a superposition or a mixture of a cleanstate and a logically erred state depending on whether theerror process is coherent or incoherent. The point is thatthe fidelity of the corrupted states, at the logical level,is greater than the corresponding fidelity for unencodedqubits. Consequently the probability of measuring thecorrect result at the end of a specific algorithm increaseswhen the system is encoded.

This example shows the basic principles of error correc-tion. In the coming sections we will briefly take a look atseveral full quantum codes, both used for quantum mem-ory and computation and we will introduce the conceptof full QEC using stabilizer codes.

1 worst case fidelity assumes that the state |ψ〉L is orthogonal tothe state σxσxσx |ψ〉L.

10

V. THE 9-QUBIT CODE: THE FIRST FULL QUANTUMCODE

The nine qubit error correcting code was first devel-oped by Shor (Sho95) in 1995 and is based largely on the3-qubit repetition code. The Shor code is a degenerate2

single error correcting code, able to correct a logical qubitfrom one bit-flip, one phase-flip or one of each, on any ofthe nine physical qubits. This code is therefore sufficientto correct for an arbitrary single qubit error [Sec. IX].The two basis states for the code are,

|0〉L =1√8

(|000〉+ |111〉)(|000〉+ |111〉)(|000〉+ |111〉)

|1〉L =1√8

(|000〉 − |111〉)(|000〉 − |111〉)(|000〉 − |111〉)(34)

and the circuit to perform the encoding is shown in Fig. 4.Correction for X errors, for each block of three qubits

FIG. 4 Circuit required to encode a single qubit with Shor’snine qubit code.

encoded to (|000〉 ± |111〉)/√

2 is identical to the threequbit code shown earlier. By performing the correctioncircuit shown in Fig. 3 for each block of three qubits, sin-gle σx ≡ X errors can be detected and corrected. Phaseerrors (σz ≡ Z) are corrected by examining the sign dif-ferences between the three blocks. The circuit shown inFig. 5 achieves this. The first set of six CNOT gates com-pares the sign of blocks one and two and the second set ofCNOT gates compares the sign for blocks two and three.Note that a phase flip on any one qubit in a block of three

2 Degenerate quantum codes are ones where different types of er-rors have the same effect on the codestates.

has the same effect, this is why the 9-qubit code is re-ferred to as a degenerate code. In other error correctingcodes, such as the 5- or 7-qubit codes (Ste96a; LMPZ96),there is a one-to-one mapping between correctable errorsand unique states. In degenerate codes such as the 9-qubit code, the mapping is not unique. Hence providedwe know in which block the error occurs it does not mat-ter which qubit we apply the correction operator to.

As the 9-qubit code can correct for a single X errorin any one block of three and a single phase error onany of the nine qubits, this code is a full quantum errorcorrecting code. Even if a bit and phase error occurson the same qubit, the X correction circuit will detectand correct for bit flips, while the Z correction circuitwill detect and correct for phase flips. As mentioned,the X error correction does have the ability to correctfor up to three individual bit flips (provided each bit flipoccurs in a different block of three). However, in general,the 9-qubit code is only a single error correcting code asit cannot handle multiple errors if they occur in certainlocations.

The 9-qubit code is in fact related to a useful class of er-ror correcting codes known as Bacon-Shor codes (Bac06).These codes have the property that certain subgroups oferror operators do not corrupt the logical space. Forexample, In the 9-qubit code, specific pairs of phaseerrors do not corrupt the logical states. Bacon-Shorcodes are very nice codes from a computer architecturalpoint of view. Error correction circuits and gates aregenerally simpler, allowing for circuit structures moreamenable to the physical restrictions of a computer ar-chitecture (AC07). Additionally, Bacon-Shor codes cor-recting a larger number of errors have a similar structure.Therefore, are able to perform dynamical switching be-tween codes, in a fault-tolerant manner. This allows usto adapt the amount of error correction to better reflectthe noise present at a physical level (SEDH08). We willreturn and revisit these codes later in section XIV.A.

VI. QUANTUM ERROR DETECTION

So far we have focused on the ability not only to de-tect errors, but also to correct them. Another approach isto not enforce the correction requirement. Post-selectedquantum computation, developed by Knill (Kni05)demonstrated that large scale quantum computing couldbe achieved with much higher noise rates when error de-tection is employed instead of more costly correction pro-tocols. The basic idea in post-selected schemes is to en-code a large number of ancilla qubits with error detectingcircuits. Sets of encoded qubits which pass error detec-tion are selected and further utilized as encoded ancillasfor error correction. In general, error detection is quickerand requires fewer qubits than performing active errorcorrection. By producing and verifying large numbersof encoded ancillas which are post-selected after verifica-tion, error correction can be performed quicker. One of

11

FIG. 5 Circuit required to perform Z-error correction for the 9-qubit code.

the downsides to these types of schemes is that althoughthey lead to large tolerable error rates, the resource re-quirements are much higher.

The simplest error detecting circuit is the 4-qubitcode (GBP97). This encodes two logical qubits on tofour physical qubits with the ability to detect a singleerror on either of the two logical qubits. The four basisstates for the code are,

|00〉 =1√2

(|0000〉+ |1111〉),

|01〉 =1√2

(|1100〉+ |0011〉),

|10〉 =1√2

(|1010〉+ |0101〉),

|11〉 =1√2

(|0110〉+ |1001〉).

(35)

Fig. 6 illustrates the error detection circuit that can beutilized to detect a single bit and/or phase flip on one ofthese encoded qubits. If a single bit and/or phase flip oc-curs on one of the four qubits then the ancilla qubits willbe measured in the state |1〉. For example, let us considerthe cases when a single bit flip occurs on one of the fourqubits. The state of the system, just prior to the mea-surement of the ancilla, is given in Table. V. Regardlessof the location of the bit flip, the ancilla system is mea-sured in the state |10〉. Similarly if one considers a singlephase error on any of the four qubits the ancilla mea-surement will return |01〉. In both cases no information

Error Location Final State, |data〉 |ancilla〉No Error |ψ〉L |00〉Qubit 1 X1 |ψ〉L |10〉Qubit 2 X2 |ψ〉L |10〉Qubit 3 X3 |ψ〉L |10〉Qubit 4 X4 |ψ〉L |10〉

TABLE V Qubit and ancilla state, just prior to measurementfor the 4-qubit error detection code when a single bit-flip hasoccurred on at most one of the four qubits.

is obtained regarding where the error has occurred, henceit is not possible to correct the state. Instead the circuitcan must reset and re-run.

VII. STABILISER FORMALISM

So far we have described error correcting codes fromthe state vector representation of their encoded states.This is a rather inefficient method for describing thecodes as the state representations and circuits will dif-fer from code to code. The majority of error correctingcodes that are used within the literature are members ofa class known as stabilizer codes. Stabilizer codes arevery useful to work with. The general formalism appliesbroadly and there exists general rules to construct prepa-ration circuits, correction circuits and fault-tolerant log-ical gate operations once the stabilizer structure of the

12

FIG. 6 Circuit required to detect errors in the 4-qubit error detection code. If both ancilla measurements return |0〉, then thecode state is error free. If either measurement returns |1〉, an error has occurred. Unlike the 9-qubit code, the detection of anerror does not give sufficient information to correct the state.

code is known.The stabilizer formalism was first introduced by Daniel

Gottesman (Got97) and uses the Heisenberg representa-tion for quantum mechanics. Describing quantum statesin terms of operators rather than the states. A state |ψ〉is defined to be stabilized by some operator, K, if it is a+1 eigenstate of K, i.e.

K |ψ〉 = |ψ〉 . (36)

For example, the single qubit state |0〉 is stabilized bythe operator K = σz, i.e.

σz |0〉 = |0〉 . (37)

We can definine multi-qubit states in the same way, byexamining some of the group properties of multi-qubitoperators.

Within the group of all possible, single qubit opera-tors, there exists a subgroup, denoted the Pauli group,P, which contains the following elements,

P = {±σI ,±iσI ,±σx,±iσx,±σy,±iσy,±σz,±iσz}.(38)

By utilizing the commutation and anti-commutationrules for the Pauli set, {σi}i=x,y,z,

[σi, σj ] = 2iεijkσk, {σi, σj} = 2δij , (39)

where,

εijk =

{+1 for (i, j, k) ∈ {(1, 2, 3), (2, 3, 1), (3, 1, 2)}−1 for (i, j, k) ∈ {(1, 3, 2), (3, 2, 1), (2, 1, 3)}0 for i = j, j = k, or k = i

(40)and

δij =

{1 for i = j0 for i 6= j

(41)

it is easy to show that P forms a group under matrixmultiplication.

The Pauli group extends over N -qubits by simply tak-ing the N fold tensor product of all elements of P, de-noted as,

PN = P⊗N . (42)

An N -qubit stabilizer state, |ψ〉N is then defined by theN generators of an Abelian (all elements commute) sub-group, G, of the N -qubit Pauli group,

G ={ Ki | Ki |ψ〉 = |ψ〉 , [Ki,Kj ] = 0, ∀ (i, j)} ⊂ PN .(43)

The state |ψ〉N can be equivalently defined either throughthe state vector representation or by specifying the gener-ators of the stabilizer group, G. As each stabilized state,|ψ〉, satisfies, K |ψ〉 = |ψ〉, each stabilizer squares to theidentity, K ·K = I.

Many extremely useful multi-qubit states are stabi-lizer states, including two-qubit Bell states, Greenberger-Horne-Zeilinger (GHZ) states (GHZ89; GHSZ90), Clus-ter states (BR01; RB01) and codeword states for QEC.As an example, consider a three qubit GHZ state,

|GHZ〉3 =|000〉+ |111〉√

2. (44)

This state can be expressed via any three linearly inde-pendent generators of the |GHZ〉3 stabilizer group,

K1 = σx ⊗ σx ⊗ σx ≡ XXX,K2 = σz ⊗ σz ⊗ σI ≡ ZZI,K3 = σI ⊗ σz ⊗ σz ≡ IZZ,

(45)

where the right-hand side of each equation is the short-hand representation of stabilizers. Similarly, the four or-

13

thogonal Bell states,

∣∣Φ±⟩ =|00〉 ± |11〉√

2,

∣∣Ψ±⟩ =|01〉 ± |10〉√

2,

(46)

are stabilized by the operators, K1 = (−1)aXX, andK2 = (−1)bZZ, where [a, b] ∈ {0, 1}. Each of the fourBell states correspond to the four ±1 eigenstate combi-nations of these two operators,

Φ+ ≡(K1 = XXK2 = ZZ

)Φ− ≡

(K1 = −XXK2 = ZZ

)Ψ+ ≡

(K1 = XXK2 = −ZZ

)Ψ− ≡

(K1 = −XXK2 = −ZZ

) (47)

VIII. QUANTUM ERROR CORRECTION WITHSTABILISER CODES

The use of the stabilizer formalism to describe quan-tum error correction codes is extremely useful since itallows easy synthesis of correction circuits and also al-lows for quick determination of what logical operationscan be applied directly on encoded data. The link be-tween stabilizer codes and stabilizer states comes aboutby defining a relevant coding subspace within the largerHilbert space of a multi-qubit system.

To illustrate this reduction let us examine a simple twoqubit example. A 2-qubit system has a Hilbert spacedimension of four, however if we require that this twoqubit state is stabilized by the XX operator, then thereare only two orthogonal basis states which satisfies thiscondition,

|0〉L ≡1√2

(|01〉+ |10〉) , |1〉L ≡1√2

(|00〉+ |11〉) ,(48)

which can be used to define a effective logical qubit.Hence by using stabilizers we can reduce the size of theHilbert space for a multi-qubit system to an effectivesingle qubit system. In the context of QEC, the sta-bilizers that are used to define the logical subspace areutilized to detect and correct for errors. A stabilizer codeis therefore a subspace defined via stabilizer operators fora multi-qubit system.

Returning to QEC, the example we focus on is the mostwell known quantum code; the 7-qubit Steane code firstproposed in 1996 (Ste96a). The 7-qubit code is definedas a [[n, k, d]] = [[7, 1, 3]] quantum code, where n = 7physical qubits encode k = 1 logical qubit with a distancebetween basis states d = 3, correcting t = b(d−1)/2c = 1error. As the code contains a single logical qubit, the codemust contain two valid code states: |0〉L and |1〉L basisstates which are, in state vector notation,

|0〉L =1√8

(|0000000〉+ |1010101〉+ |0110011〉+ |1100110〉+ |0001111〉+ |1011010〉+ |0111100〉+ |1101001〉),

|1〉L =1√8

(|1111111〉+ |0101010〉+ |1001100〉+ |0011001〉+ |1110000〉+ |0100101〉+ |1000011〉+ |0010110〉).(49)

For a general 7-qubit state, the total dimension of theHilbert space is 27. For a single logically encodedqubit, we must restrict this to a 2-dimensional subspacespanned by the states in Eq. (49). This reduction can beclearly seen via stabilizers.

The stabilizer set for the 7-qubit code is fully specifiedby the six operators,

K1 = IIIXXXX, K2 = XIXIXIX,

K3 = IXXIIXX, K4 = IIIZZZZ

K5 = ZIZIZIZ, K6 = IZZIIZZ.

(50)

Each of the valid codestates for the 7-qubit code are sta-bilized by these operators. As the dimensionality of a7-qubit system is 27 and there are six stabilizers, the to-tal dimension of this subspace defined by the stabilizergroup is 27−6 = 2. The stabilizer set now defines an effec-tive 2-dimensional subspace, and thus a single encoded

qubit3.

The final operator fixes the encoded state to one ofthe two codewords. For the Steane code this operatoris K7 = ZZZZZZZ = Z⊗7, where K7 |0〉L = |0〉L andK7 |1〉L = − |1〉L. Notice that these generators for thestabilizer set separate into elements consisting solely ofX or Z operators. This defines the code as a Calderbank-Shor-Steane (CSS) code. CSS codes are useful since theyallow for the straightforward application of several logicalgate operations directly to the encoded data [Section XI]

3 In general, for an n qubit system, the total dimensionality of theHilbert space is 2n, if a stabilizer set is defined over this systemcontaining k linearly independent generators, then the dimensionof the subspace is 2n−k and therefore the stabilizer set defines asubspace containing n− k logical qubits.

14

and are easy to derive from classical codes.Although the 7-qubit code is the most well-known sta-

bilizer code, there are other stabilizer codes which en-code multiple logical qubits and correct for more er-rors (Got97). Despite these advantages, larger codes gen-erally require more physical qubits and more complicatederror correction circuits, making them less amenable tobeing efficiently implemented on physical computer archi-tectures. Tables VI and VII show the stabilizer structureof two other well-known codes. The 9-qubit code (Sho95)examined earlier, and the 5-qubit code (LMPZ96) whichrepresents the smallest possible quantum code that cor-rects for a single error.

K1 Z Z I I I I I I IK2 Z I Z I I I I I IK3 I I I Z Z I I I IK4 I I I Z I Z I I IK5 I I I I I I Z Z IK6 I I I I I I Z I ZK7 X X X X X X I I IK8 X X X I I I X X X

TABLE VI The eight stabilizers for the 9-qubit Shor code,encoding nine physical qubits into one logical qubit to correctfor a single X and/or Z error.

K1 X Z Z X IK2 I X Z Z XK3 X I X Z ZK4 Z X I X Z

TABLE VII The four stabilizers for the [[5,1,3]] quantumcode, encoding five physical qubits into one logical qubit tocorrect for a single X, Y or Z error. Unlike the 7- and 9-qubit codes, the [[5,1,3]] code is a non-CSS code, since thestabilizer set does not separate into X and Z sectors. Addi-tionally, this code can only correct a single error where as the7- and 9-qubit codes can correct for a maximum of 2 errors (asingle X and Z error provided they occur on different qubits)

A. State preparation

Using the stabilizer structure for QEC codes, the log-ical state preparation and error correcting procedure isstraightforward. Recall that valid codeword states aredefined as simultaneous +1 eigenstates of each generatorof the stabilizer group. In order to prepare a logical statefrom an arbitrary input, we need to project qubits intoeigenstates of each of these operators.

Consider the circuit shown in Fig. 7. For an arbitraryinput state, |ψ〉I , an ancilla which is initialized in the|0〉 state is used as a control qubit for a unitary andHermitian operation (U† = U , U2 = I) on |ψ〉I . After

MH H

U

FIG. 7 Quantum Circuit required to project an arbitrarystate, |ψ〉I into a ±1 eigenstate of the Hermitian operator,

U = U†. The measurement result of the ancilla determineswhich eigenstate |ψ〉I is projected to and since the operator,U is Hermitian and unitary can only have the two eigenvalues±1.

the second Hadamard gate is performed, the state of thesystem is,

|ψ〉F =1

2(|ψ〉I +U |ψ〉I) |0〉+

1

2(|ψ〉I−U |ψ〉I) |1〉 . (51)

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

|ψ〉F = |ψ〉I + U |ψ〉I . (52)

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

|ψ〉F = |ψ〉I − U |ψ〉I , (53)

which is the −1 eigenstate of U . Therefore, provided Uis Hermitian, the general circuit of Fig. 7 will projectan arbitrary input state to a ±1 eigenstate of U .4 Thisprocedure is well known and is referred to as either a“parity” or “operator” measurement (NC00).

From this construction it should be clear how QECstate preparation proceeds. Taking the [[7, 1, 3]] codeas an example (however this technique is not unique oroptimal for preparing and correcting the 7-qubit code(Ste97a; Ste02)), 7-qubits are first initialized in the state

|0〉⊗7. The circuit shown in Fig. 7 is applied three times

with U = K1,K2,K3, projecting the input state into asimultaneous ±1 eigenstate of each X generator of thestabilizer group for the [[7, 1, 3]] code. The result of eachoperator measurement is then used to classically con-trol a single qubit Z gate which is applied to one of theseven qubits at the end of the preparation. This single Zgate converts any −1 projected eigenstates into +1 eigen-states. Notice that the final three stabilizers do not need

4 An operator, U , which is both Hermitian and unitary can onlyhave eigenvalues of ±1

15

to be measured due to the input state, |0〉⊗7, already be-

ing a +1 eigenstate of K4,K5 and K6. Additionally asthe state |0〉⊗7

is also a +1 eigenstate of K7, the initialstate will be |0〉L state. Fig. 8 illustrates the final circuit,where instead of one ancilla, three are utilized to speedup the state preparation by performing each operatormeasurement in parallel.

M0 H H

K

M0 H H

M0 H H

KK

0

0

Zi

1

2

3

1 2 3

1

7

i = 1 +2 + 4 M M M

2 3 1

FIG. 8 Quantum circuit to prepare the [[7, 1, 3]] logical |0〉state. The input state |0〉⊗7 is projected into an eigenstateof each of the X stabilizers shown in Eq. (50). After eachancilla measurement the classical results are used to applya single qubit Z gate to qubit i = 1M2 + 2M3 + 4M1 whichconverts the state from a −1 eigenstates of (K1,K2,K3) to+1 eigenstates.

As a quick aside, let us detail exactly how the rele-vant logical basis states can be derived from the stabi-lizer structure of the code by utilizing this preparationprocedure. We will use the stabilizer set shown in Ta-ble VII to calculate the |0〉L state for the 5-qubit codeas we have not yet explicitly shown the state vectors forthe two logical state. The four stabilizer generators aregiven by,

K1 = XZZXI, K2 = IXZZX,

K3 = XIXZZ, K4 = ZXIXZ.(54)

In an identical way to the 7-qubit code, projecting anarbitrary state into a +1 eigenstate of these operatorsdefine the two logical basis states, |0〉L and |1〉L. Thelogical operator, Z = ZZZZZ, then fixes the state toeither |0〉L or |1〉L. Therefore, calculating |0〉L from someinitial un-encoded state requires us to project the initialstate into a +1 eigenstate of these operators. If we takethe initial, un-encoded state as |00000〉, then it is alreadya +1 eigenstate of Z. Therefore, to find |0〉L we simplycalculate,

|0〉L =

4∏i=1

(I⊗5 +Ki) |00000〉 , (55)

up to normalization. Expanding out this product, we

find,

|0〉L =1

4( |00000〉+ |01010〉+ |10100〉 − |11110〉+|01001〉 − |00011〉 − |11101〉 − |10111〉+|10010〉 − |11000〉 − |00110〉 − |01100〉−|11011〉 − |10001〉 − |01111〉+ |00101〉).

(56)Note, that the above state vector does not match up withthose given in (LMPZ96)5. However, these vectors areequivalent up to local rotations on each qubit.

B. Error correction

Error correction using stabilizer codes is an extensionof the state preparation. Consider an arbitrary singlequbit state that has been encoded as,

α |0〉+ β |1〉 → α |0〉L + β |1〉L = |ψ〉L . (57)

Now assume that an error occurs on one (or multiple)qubits which is described via the operator E, where E isa combination of X and/or Z errors over the N physicalqubits of the logical state (and therefore an element ofthe N -qubit Pauli group, PN ). By definition of stabilizercodes, Ki |ψ〉L = |ψ〉L, i ∈ [1, .., N − k], for a code en-coding k logical qubits. Hence the erred state, E |ψ〉L,satisfies,

KiE |ψ〉L = (−1)mEKi |ψ〉L = (−1)mE |ψ〉L . (58)

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

The general procedure for error correction is identicalto state preparation. Each of the code stabilizers is se-quentially measured. Since a error free state is alreadya +1 eigenstate of all the stabilizers, errors which anti-commute with any of the stabilizers describing the codewill flip the relevant eigenstate and consequently measur-ing the parity of these stabilizers will return a result of|1〉. Taking the [[7, 1, 3]] code as an example, if the erroroperator is E = Xi (where i = 1, ..., 7), representing abit-flip on any one of the 7 physical qubits, then regard-less of the location, E will anti-commute with a uniquecombination of K4,K5 and K6. Hence the classical re-sults of measuring these three operators will indicate ifand where a single X error has occurred. Similarly, ifE = Zi, then the error operator will anti-commute witha unique combination of, K1,K2 and K3. Consequently,

5 The stabilizer formalism was introduced after the 5-qubit code.

16

the first three stabilizers for the [[7, 1, 3]] code correspondto Z error correction while the second three stabilizerscorrespond to X error correction. Note that correctionfor Pauli Y errors is achieved by correcting in the X andZ sector since a Y error on a single qubit is equivalent toboth an X and Z error on the same qubit, i.e. Y = iXZ.

The circuit shown in Fig. 9 illustrates the circuit forfull error correction with the [[7, 1, 3]] code. As you cansee it is simply an extension of the preparation circuitshown in Fig. 8, where all six stabilizers are measuredacross the data block. Even though we have specificallyused the [[7, 1, 3]] code as an example, this procedure forerror correction and state preparation will work for allstabilizer codes (although other correction procedures arepossible (Ste97a; Ste02; Kni05)).

IX. DIGITIZATION OF QUANTUM ERRORS

Up until now we have remained fairly abstract regard-ing the analysis of quantum errors. Specifically, we haveexamined QEC from the standpoint of a discrete set ofPauli errors occurring at certain locations within a largerquantum circuit. In this section we examine how thisanalysis of errors relates to some of the more realistic pro-cesses such as environmental decoherence and systematicgate errors.

Digitization of quantum noise is often assumed whenpeople examine the stability of quantum circuit designor attempt to calculate thresholds for concatenated er-ror correction [Section. X.C]. However, the link betweendiscrete Pauli errors to more general, continuous noiseonly makes sense when we consider the stabilizer natureof the correction procedure. Recall from section VII thatcorrection is performed by re-projecting a potentially cor-rupt data block into +1 eigenstates of the code stabiliz-ers. A general continuous mapping from a “clean” code-word state to a corrupt one will not be eigenstates ofthe code stabilizers. Instead they will be in superposi-tions of eigenstates. Measuring the parity of each of thestabilizers acts to digitize the quantum noise. We willfirst introduce how a coherent systematic error, causedby imperfect implementation of quantum gates, are dig-itized during correction, after which we will briefly dis-cuss environmental decoherence from the standpoint of aMarkovian decoherence model.

A. Systematic gate errors

We have already shown a primitive example of howsystematic gate errors are digitized into a discrete set ofPauli operators in Sec. III. However, in that case we onlyconsidered a very restrictive type of error, namely thecoherent operator U = exp(iεX). We can easily extendthis analysis to cover all types of systematic gate errors.Consider an N qubit unitary operation, UN , which isvalid on encoded data. Assume that UN is applied in-

accurately such that the resultant operation is actuallyUN . Given a general encoded state |ψ〉N , the final statecan be expressed as,

UN |ψ〉L = UEUN |ψ〉L =∑j

αjEj |ψ2〉L , (59)

where |ψ2〉L = UN |ψ〉L is the perfectly applied N qubitgate, (the stabilizer group for |ψ′〉L remains invariant un-der the operation UN [see Sec. XI]) and UE is a coher-ent error operator which is expanded in terms of the Nqubit Pauli Group, Ej ∈ PN . Now append two ancilla

blocks, |A0〉X and |A0〉Z . These are generally initial-ized to the state that corresponds to no detected errors(but can be other initial states up to a redefinition of themeasurement results) and are used for X and Z correc-tion. We then run the syndrome extraction procedure,which we represent by the unitary operator, UQEC. Itwill be assumed that |ψ〉L is encoded with a QEC codewhich can correct for a single error (both X and/or Z),and the error operators Ej are a maximum of weightone (i.e. Ej contains at most one non-identity term e.g.

E1 = X1 ⊗ I⊗(N−1)). Hence there is a one-to-one map-ping between the error operators, Ej , and the orthogonalbasis states of the ancilla blocks,

UQECU′N |ψ〉L |A0〉X |A0〉Z

= UQEC

∑j

αjEj |ψ′〉L |A0〉X |A0〉Z

=∑j

αjEj |ψ′〉L |Aj〉X |Aj〉Z .

(60)

The ancilla blocks are then measured, projecting the datablocks into the state Ej |ψ′〉L with probability |αj |2. Af-

ter measurement the correction E†j is applied based onthe syndrome result. As the error operation Ej is simplyan element of PN , correcting for X and Z independentlyis sufficient to correct for all error operators (as Y errorsare corrected when a bit and phase error is detected andcorrected on the same qubit).

For well designed gates, very small systematic inac-curacies lead to the expansion co-efficient α0 ≈ 1, withall other coefficients, αj 6=0 � 1. Hence during correc-tion there will be a very high probability that no er-ror 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 measuredforces any continuous noise operator to collapse. Thestrength of the error is then related to the probabilitythat the data block collabses to a specific Pauli erroracting on the codestate. The physical mechanisms whichare used to construct quantum gates is what determinesthe form of UE and hence the form of the error operators,Ej and their respective coefficients, αj .

17

M0 H H

K

M0 H H

M0 H H

KK Zi

1

2

3

1 2 3

1

7

i = 1 +2 + 4 M M M

2 3 1

M0 H H

K

M0 H H

M0 H H

KK Xi

4

5

6

4 5 6

i = 1 +2 + 4 M M M

5 6 4

FIG. 9 Quantum circuit to to correct for a single X and/or Z error using the [[7, 1, 3]] code. Each of the six stabilizers aremeasured, with the first three detecting and correcting for Z errors, while the last three detect and correct for X errors.

B. Environmental decoherence

A complete analysis of environmental decoherence inrelation to quantum information is a lengthy topic. In-stead of a detailed review, we will instead present a sim-plified example to highlight how QEC relates to environ-mental effects.

The Lindblad formalism (Gar91; NC00; DWM03) pro-vides an elegant method for analyzing the effect of de-coherence on open quantum systems. This model doeshave several assumptions, most notably that the en-vironmental bath couples weakly to the system (Bornapproximation), the system and environment are ini-tially in some separable state and that each qubit expe-riences un-correlated noise (Markovian approximation).While these assumptions are utilized for a variety ofsystems (BHPC03; BM03; BKD04), it is known thatthey may not hold in some cases (HMCS00; MCM+05;APN+05; ALKH02). This is particularly importantin superconducting systems, where decoherence can becaused by small numbers of fluctuating charges. In thiscase more specific decoherence models need to be consid-ered.

Using this formalism, the evolution of the density ma-trix can be written as,

∂tρ = − i~

[H, ρ] +∑k

ΓkLk[ρ], (61)

where H is the Hamiltonian, representing coherent, dy-

namical evolution of the system and Lk[ρ] = ([Lk, ρL†k]+

[Lkρ, L†k])/2 represents the incoherent evolution. The op-

erators Lk are known as the Lindblad quantum jumpoperators and are used to model specific decoherencechannels, with each operator associated with some rateΓk ≥ 0. This differential equation is known as the quan-tum Louiville equation or more generally, the density ma-trix master equation.

To link Markovian decoherence to QEC, consider aspecial set of decoherence channels which represent asingle qubit undergoing dephasing, spontaneous emis-sion and spontaneous absorption. This helps to simplifythe calculation. Dephasing of a single qubit is mod-eled by the Lindblad operator L1 = Z while sponta-neous emission/absorption are modeled by the operatorsL2 = |0〉 〈1| and L3 = |1〉 〈0| respectively. For the sake ofsimplicity, we assume that absorption/emission occur atthe same rate, Γ. Although this is unphysical, it doessimplify the calculation significantly for this example.The density matrix evolution is given by,

∂tρ = − i~

[H, ρ] + ΓZ(ZρZ − ρ) +Γ

2(XρX + Y ρY − 2ρ).

(62)If we assumed that the qubit is not undergoing any co-herent evolution (H = 0), i.e. a memory stage withina quantum algorithm, then Eq. (62) can be solved byre-expressing the density matrix in the Bloch formal-ism. Set ρ(t) = I/2 + x(t)X + y(t)Y + z(t)Z, thenEq. (62) with H = 0 reduces to ∂tS(t) = AS(t) withS(t) = (x(t), y(t), z(t))T and

A =

−(Γ + 2Γz) 0 00 −(Γ + 2Γz) 00 0 −2Γ

. (63)

This differential equation is easy to solve, leading to,

ρ(t) = [1− p(t)]ρ(0) + px(t)Xρ(0)X

+ py(t)Y ρ(0)Y + pz(t)Zρ(0)Z,(64)

where,

px(t) =py(t) =1

4(1− e−2Γt),

pz(t) =1

4(1 + e−2Γt − 2e−(Γ+2Γz)t),

p(t) = px(t) + py(t) + pz(t).

(65)

18

If this single qubit is part of an encoded data block, theneach term represents a single error on the qubit expe-riencing decoherence. Two blocks of ancilla qubits, ini-tialized to the state corresponding to no detected error,are added to the system. The error correction protocolis then run. Once the ancilla qubits are measured, thestate will collapse to no error with probability 1 − p(t),or a single X,Y or Z error, with probabilities px(t), py(t)and pz(t) respectively.

We can also see how temporal effects are incorporatedinto the error correction model. The temporal integra-tion window t of the master equation will influence howprobable an error is detected for a fixed rate Γ. Thelonger between correction cycles, the more probable thequbit experiences an error.

C. More general mappings

Both the systematic gate errors and the errors inducedby environmental decoherence illustrate the digitizationeffect of QEC. However, we can generalize digitizationto other mappings of the density matrix. In this caseconsider a more general Krauss map on a multi-qubitdensity matrix,

ρ→∑k

A†kρAk, (66)

where∑A†kAk = I. For the sake of simplicity let us

choose a simple mapping where A1 = (Z1 + iZ2)/√

2 andAk = 0 for k 6= 1. This mapping essentially representsdephasing on two qubits. However, this type of map-ping (when considered in the context of error correction)represents independent Z errors on either qubit one ortwo.

The above discussion assumes that we are working witha non-degenerate quantum code. If the code is degener-ate, i.e. if the errors Z1 and Z2 have the same effecton the codestates then the correction protocol does notsimplify this error mapping as described above.

To illustrate, first expand out the density matrix (ne-glecting normalization),

ρ→ A†1ρA1 = Z1ρZ1 +Z2ρZ2− iZ1ρZ2 + iZ2ρZ1. (67)

Note that only the first two terms in this expansion, ontheir own, represent physical mixtures. However, thelast two off-diagonal terms are removed by the processof syndrome extraction and are irrelevant in the contextof QEC. To illustrate, we assume that ρ represents aprotected qubit, where Z1 and Z2 are physical errors onqubits comprising the code block. As we are only con-sidering phase errors in this example, we will ignore Xcorrection (but the analysis automatically generalizes ifthe error mapping contains X terms). A fresh ancillablock, represented by the density matrix ρz0 is coupled to

the system and the unitary UQEC is run,

U†QECρ′ ⊗ ρz0UQEC = Z1ρZ1 ⊗ |Z1〉 〈Z1|

+ Z2ρZ2 ⊗ |Z2〉 〈Z2|− iZ1ρZ2 ⊗ |Z1〉 〈Z2|+ iZ2ρZ1 |Z2〉 〈Z1| ,

(68)

where |Z1〉 and |Z2〉 represent the two orthogonal syn-drome states of the ancilla that are used to detect phaseerrors on qubits one and two respectively. The importantpart of the above expression is that when the syndromequbits are measured, the state collapses to,

ρ→ 〈Z1| ρ |Z1〉 |Z1〉 〈Z1|Tr(ρ |Z1〉 〈Z1|)

or ρ→ 〈Z2| ρ |Z2〉 |Z2〉 〈Z2|Tr(ρ |Z2〉 〈Z2|)

.

(69)

The two cross terms in the above expression are neverobserved. In this mapping the only two possible statesthat exist after the measurement of the ancilla systemare,

Z1ρZ1 ⊗ |Z1〉 〈Z1| with Probability =1

2,

Z2ρZ2 ⊗ |Z2〉 〈Z2| with Probability =1

2.

(70)

Therefore, not only are the cross terms eliminated via er-ror correction but the final density matrix again collapsesto a single error perturbation of “clean” codeword stateswith no correlated errors.

Consequently, it is common in standard QEC analysisto assume that discrete X and/or Z errors are appliedstochastically to each qubit after each elementary gateoperation, measurement, initialization and memory stepwith some probability p. The QEC protocol itself digi-tizes the continuous noise, either coherent or incoherenterrors, into a discrete set of bit and/or phase flips. Theset of discrete errors is determined by the set of errorsthat are distinguishable by the quantum code used. Themagnitude of the continuous error is translated to theprobability of detecting a discrete error. In this way er-ror correction can be analyzed by assuming perfect gateoperations and discrete, probabilistic errors. The proba-bility of these errors occurring can then be independentlycalculated via analysis of the physical mechanisms whichproduce errors. While a local, stochastic error modelis generally the most common, depending on the physi-cal system under consideration and the type of quantumcodes being used a more complicated analysis may beneeded (Pre98).

X. FAULT-TOLERANT QUANTUM ERRORCORRECTION AND THE THRESHOLD THEOREM

Section VII detailed the protocols required to correctfor quantum errors, however in the discussion so far, wehave implicitly assumed the following,

19

1. Errors only occur during “memory” regions, i.e.when quantum operations or error correction arenot being performed and ancilla qubits are errorfree.

2. The quantum gates themselves do not induce anysystematic errors within the logical data block.

Clearly these are two very unrealistic assumptions.Fault-tolerant QEC is how we address these two issues.As the name suggests, fault-tolerance is a design method-ology that allows us to tolerate faults, allowing QEC toremain effective. Combining error correction techniqueswith fault-tolerance allows us to design correction proce-dures and logical gate operations such that they can stillfunction when the above assumptions are relaxed.

A. Error propagation

Before discussing the nature of fault-tolerant computa-tion, we first examine how errors can propagate in quan-tum circuits. There are essentially two dominant chan-nels that can cause errors to be copied, the first is quan-tum gates. For obvious reasons, gates operating on singlequbits do not copy errors, however quantum gates whichcouple qubits can cause errors to propagate.

For example, take the two qubit state Ej |ψ〉, whereEj = {X1I2, Y1I2, Z1I2, I1X2, I1Y2, I1Z2} are each singlequbit errors (either on qubit one or two respectively). Wenow perform a CNOT operation, U =CNOT, where thecontrol is qubit one. This gives,

UEj |ψ〉 = (UEjU†)U |ψ〉 , (71)

using the identity (U†U) = I. The effect of the gate isto transform the error Ej to E′j = (UEjU

†). For the sixsingle qubit errors, this gives,

U(X1I2)U† = X1X2,

U(Y1I2)U† = Y1X2,

U(Z1I2)U† = Z1I2,

U(I1X2)U† = I1X2,

U(I1Y2)U† = Z1Y2,

U(I1Z2)U† = Z1Z2.

(72)

Therefore, the CNOT gate copies X errors from the con-trol qubit to the target and copies Z errors from thetarget to the control. Error propagation rules for anymulti-qubit unitary can also be calculated for an arbi-trary gate, U , and error, E.6

6 If U is not a member of the Clifford group (operators which mapPauli operators to Pauli operators) then E will map to a linearcombination of Pauli errors.

The above example assumes a perfect 2-qubit gate op-eration, however the gates themselves can also introducemultiple errors when they fail. In the case of coherenterrors, an arbitrary 2-qubit unitary, U , can be written inthe form, UEUp, where Up is the perfectly applied gateand UE is some coherent error operator. This error op-erator can be expressed as a linear combination of the2-qubit Pauli group,

UE =

4∑(i,j)=1

di,j σi ⊗ σj , [σ1, σ2, σ3, σ4] = [I,X, Y, Z]

(73)Therefore inaccurate application of the gate Up (includ-ing complete failure) can introduce a single X,Y or Zerror to each of the two qubits or it can introduce an er-ror to both qubits (the details of what kind of errors canbe introduced by faulty gates is dependent on the mecha-nisms causing the failure). Therefore, not only can gatescoupling qubits copy pre-existing errors but a single fail-ure event can introduce errors on both qubits involved inthe interaction. Correlated errors also occur in the den-sity matrix representation when incoherent noise causesgate inaccuracies. This generalizes for higher order op-erations, e.g. errors on three qubit gates can introduceerrors on all three qubits, etc.

M

X|ψ〉 XM |ψ〉FIG. 10 Error propagation due to measurement error. If themeasurement result for qubit one is faulty, we inadvertentlyintroduce an error to the second qubit.

A second process which can cause errors to cascadeis the classical correction of quantum data from a mea-surement result7. Take the circuit shown in Fig. 10. Themeasurement result on the top qubit is used to determineif the gate, X, is applied to the second qubit. In this casethe gate is applied if the upper qubit is measured in thestate |1〉. If we now assume that this measurement isfaulty, then with some probability the “classical” infor-mation extracted from the measurement device is wrong.Therefore the correction that is applied to the secondqubit should not have been applied. Not only has a bitflip error now occurred on qubit one (due to the inaccu-rate measurement result), but we also have accidentallyintroduced a bit flip error on the second qubit due to thisinaccurate information.

7 It should be noted that this process is equivalent to directlycoupling qubits with quantum gates and then measuring one ofthe qubits, hence errors will be copied in the same manner asdirect coupling.

20

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

B. Fault-tolerance

The concept of fault-tolerance in computation is nota new idea, it was first developed in relation to classi-cal computing (Neu55; G83; Avi87). However, in recentyears the precise manufacturing of digital circuitry hasmade large-scale error correction and fault-tolerant cir-cuits largely unnecessary.

The basic principle of fault-tolerance is that the cir-cuits used for gate operations and error correction proce-dures should not cause errors to cascade. As shown in theprevious section, gates which couple multiple qubits andmeasurements which are used to control a quantum op-eration can cause errors to be copied. How do we designoperations to avoid cascading errors in quantum algo-rithms?

This can be seen more clearly when we look at a sim-ple CNOT operation between two qubits [Fig. 11]. In thiscircuit we are performing a sequence of three CNOT gateswhich act to take the state |111〉 |000〉 → |111〉 |111〉. InFig. 11a we consider a single X error which occurs onthe top most qubit prior to the first CNOT. This sin-gle error will cascade through each of the three gatessuch that the X error has now propagated to four qubits.Fig. 11b shows a slightly modified design that implementsthe same operation, but the singleX error now only prop-agates to two of the six qubits. If we consider each blockof three as a single logical qubit, then the staggered cir-cuit will only induce a total of one error in each logicalblock, given a single X error occurred somewhere duringthe circuit. Therefore, one of the standard definitions offault-tolerance is,

fault-tolerant circuit element: A single error will causeat most one error in the output for each logical qubitblock.

It should be stressed that the idea of fault-toleranceis a discrete definition, either a certain quantum opera-tion is fault-tolerant or it is not. What is defined to befault-tolerant can change depending on the error correc-tion code used. For example, for a single error correctingcode, the above definition is the only one available, sinceany more than one error in a logical qubit will result inthe error correction procedure failing. However, if thequantum code employed is able to correct multiple er-rors, then the definition of fault-tolerance can be relaxed,i.e. if the code can correct three errors then circuits maybe designed such that a single failure results in at mostthree errors in the output (which is then correctable). Ingeneral, for an code correcting t = b(d − 1)/2c errors,fault-tolerance requires that ≤ t errors during an opera-tion does not result in > t errors in the output for eachlogical qubit.

C. Threshold theorem

The threshold theorem is truly a remarkable resultin quantum information and is a consequence of fault-tolerant circuit design and the ability to perform dy-namical error correction. Rather than present a detailedderivation of the theorem for a variety of noise models,we will instead take a very simple case where we utilizea quantum code that can only correct for a single er-ror, using a model that assumes uncorrelated errors onindividual qubits. For more rigorous derivations of thetheorem see (ABO97; Got97; Ali07).

Consider a quantum computer where each physicalqubit experiences either an X and/or Z error indepen-dently with probability p, per gate operation. Further-more, it is assumed that logical gate operations and errorcorrection circuits are designed according to the rules offault-tolerance and that a cycle of error correction is per-formed after each elementary logical gate operation. If anerror occurs during a logical gate operation, then fault-tolerance ensures this error will only propagate to at mostone error in each block, after which a cycle of error correc-tion will remove the error. Hence if the failure probabilityof un-encoded qubits per time step is p, then a single levelof error correction will ensure that the logical step failsonly when two (or more) errors occur. Hence the failurerate of each logical operation, to leading order, is nowp1L = cp2, where p1

L is the failure rate (per logical gateoperation) of a level-1 logical qubit and c is the upperbound for the number of possible 2-error combinationswhich can occur at a physical level within the sequenceof operations consisting of a correction cycle, the logicalgate operation and a second correction cycle (Ali07). Wenow repeat the process, encoding the qubit array fur-ther, such that a level-2 logical qubit is formed. Thisis done using the same [[n, k, d]] quantum code level-1encoded qubits. It is assumed that all error correctingprocedures and gate operations at level-2 are self-similarto the level-1 operations (i.e. the circuit structures forthe level-2 encoding are identical to the level-1 encod-ing). Therefore, if the level-1 failure rate per logical timestep is p1

L, then by the same argument, the failure rateof a level-2 operation is given by, p2

L = c(p1L)2 = c3p4.

This iterative procedure is then repeated (referred to asconcatenation) up to level-g, such that the logical failurerate, per time step, of a level-g encoded qubit is given by,

pgL =(cp)2g

c. (74)

Eq. (74) implies that for a finite physical error rate, p,per qubit, per time step, the failure rate of a level-g en-coded qubit can be made arbitrarily small if cp < 1.This inequality defines the threshold. The physical er-ror rate experienced by each qubit per time step mustbe pth < 1/c to ensure that multiple levels of concate-nated error correction reduces the failure rate of logicalcomponents.

Hence, provided sufficient resources are available, an

21

X X

X

X

X

X

X

a) b)

X

FIG. 11 Two circuits to implement the transformation |111〉 |000〉 → |111〉 |111〉. Subfigure a) shows a version where a singleX error can cascade into four errors while Subfigure b) shows an equivalent circuit where the error only propagates to a secondqubit.

arbitrarily large quantum circuit can be successfully im-plemented to arbitrary accuracy, once the physical errorrate is below threshold. The calculation of thresholdsis therefore an extremely important aspect to quantumarchitecture design. Initial estimates at the threshold,which gave pth ≈ 10−4 (Kit97; ABO97; Got97), didnot sufficiently model the physical architectures. Recentresults (SFH08; SDT07; SBF+06; MCT+04; BKSO05)have been estimated for more realistic quantum processorarchitectures, showing significant differences in thresholdwhen architectural considerations are taken into account.

XI. FAULT-TOLERANT OPERATIONS ON ENCODEDDATA

Sections VII, VIII and X showed how fault-tolerantQEC allows for any quantum algorithm to be run to ar-bitrary accuracy. However, the results of the thresholdtheorem assume that logical operations can be performeddirectly on the encoded data without the need for con-tinual decoding and re-encoding. Using stabilizer codes,a large class of operations can be performed on logicaldata in an inherently fault-tolerant way.

If a given logical state, |ψ〉L, is stabilized by K, andthe logical operation U is applied, the new state, U |ψ〉Lis stabilized by UKU†, i.e,

UKU†U |ψ〉L = UK |ψ〉L = U |ψ〉L . (75)

In order for the codeword states to remain valid, the sta-bilizer set for the code, {Gi} ∈ G, must remain fixedthrough every operation. Hence for U to be a valid oper-ation on the data, UGiU

† = Gj , Gj ∈ G ∀i. As a short-hand notation, we express this relationship as UGU† = G.

A. Single qubit operations

For an elementary operation A, the equivalent logicaloperator A will now be formed via a sequence of elemen-tary operations on the physical qubits comprising thecode block. The logical X and Z operations on a singleencoded qubit are the first examples of valid codewordoperations. Taking the [[7, 1, 3]] code as an example, Xand Z are given by,

X = XXXXXXX ≡ X⊗7,

Z = ZZZZZZZ ≡ Z⊗7.(76)

Since the single qubit Pauli operators satisfyXZX = −Zand ZXZ = −X then, XKiX = Ki and ZKiZ = Ki foreach of the [[7, 1, 3]] stabilizers given in Eq. (50). The factthat each stabilizer has a weight of four guarantees thatUKU† picks up an even number of −1 factors. Since thestabilizers remain fixed, the operations are valid. How-ever, what transformations do Eq. (76) actually performon encoded data?

For a single qubit, a bit-flip operation X takes |0〉 ↔|1〉. Recall that for a single qubit Z |0〉 = |0〉 andZ |1〉 = − |1〉, hence for X to actually induce a logi-cal bit-flip it must take, |0〉L ↔ |1〉L. For the [[7, 1, 3]]code, the final operator which fixes the logical state isK7 = Z⊗7, where K7 |0〉L = |0〉L and K7 |1〉L = − |1〉L.As XK7X = −K7, any state stabilized by K7 becomesstabilized by −K7 (and vice-versa) after the operation ofX. Therefore, X represents a logical bit flip. The sameargument can be used for Z by considering the stabilizerproperties of the states |±〉 = (|0〉 ± |1〉)/

√2. Hence, the

logical bit- and phase-flip gates can be applied directlyto logical data by simply using seven single qubit X orZ gates, [Fig. 12].

22

7

7

7

7

FIG. 12 Bit-wise application of single qubit gates in the [[7, 1, 3]] code. Logical X, Z H and P gates can trivially be appliedby using seven single qubit gates, fault-tolerantly. Note that the application of seven P gates results in the logical P † beingapplied and vice-versa.

Two other useful gates which can be applied in thismanner is the Hadamard rotation and phase gate,

H =1√2

(1 11 −1

), P =

(1 00 i

). (77)

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

HXH = Z, HZH = X,

PXP † = iXZ, PZP † = Z,(78)

a seven qubit bit-wise Hadamard gate will switch Xwith Z and therefore will simply flip {K1,K2,K3} with{K4,K5,K6}, and is a valid operation. The bit-wiseapplication of the P gate will leave any Z stabilizer in-variant, but takes X → iXZ. This is still valid, sinceprovided there are a multiple of four non-identity opera-tors for each generator of the stabilizer group, the factors

of i will cancel. Hence seven bit-wise P gates is valid forthe [[7, 1, 3]] code.

What do these logical operators do to the logical state?For a single qubit, the Hadamard gate flips any Z sta-bilized state to a X stabilized state, i.e |0, 1〉 ↔ |+,−〉.Looking at the transformation of K7, using H = H⊗7 wehave, HK7H = X⊗7. Therefore, the bit-wise Hadamardgate, H, is the logical Hadamard operation. The singlequbit P gate leaves a Z stabilized state invariant, whilean X eigenstate becomes stabilized by iXZ. Hence, de-noting P † = P⊗7, P (X⊗7)P † = −i(XZ)⊗7 and the bit-wise gate, P †, is the logical P † gate. Similarly, bit-wisegate, P = P †⊗7, enacts a logical P gate [Fig. 12]. Eachof these fault-tolerant operations on a logically encodedblock are commonly referred to as transversal operations.A transversal operation can be defined as a logical oper-ator which is formed by applying the individual physicaloperators to each qubit in the code block (or betweentwo equivalent physical qubits in the case of entanglingoperations such as the CNOT gate shown below). Thephysical operations forming a transversal logical oper-

23

ator need not be the same, for example in Fig.12, theP † gate is formed via individual P operations and visaversa. Hence, valid transversal gates may possibly beconstructed from a set of physical operations which areunique to each qubit.

B. Two-qubit gate

A two-qubit logical CNOT operation can also be ap-plied in the same way, as a transversal bit-wise operationof individual CNOT gates between corresponding phys-ical qubits. For un-encoded qubits, a CNOT operationperforms the following mapping on the two qubit stabi-lizer set,

X ⊗ I → X ⊗X,I ⊗ Z → Z ⊗ Z,Z ⊗ I → Z ⊗ I,I ⊗X → I ⊗X.

(79)

Where the first operator corresponds to the control qubitand the second operator corresponds to the target. Nowconsider the bit-wise application of seven CNOT gatesbetween logically encoded blocks of data [Fig. 13]. Firstthe stabilizer set must remain invariant,

CNOT G CNOT = {CNOT (Ki ⊗Kj) CNOT} = G.(80)

i.e. each element in G must be mapped to another el-ement of G. Table VIII details the transformation forall the stabilizer generators under seven bit-wise CNOTgates, demonstrating that this operation is valid on the[[7, 1, 3]] code. The transformations in Eq. (79) are triv-ially extended to the logical space, showing that sevenbit-wise CNOT gates invoke a logical CNOT operation.

X ⊗ I → X ⊗ X,I ⊗ Z → Z ⊗ Z,Z ⊗ I → Z ⊗ I,I ⊗ X → I ⊗ X.

(81)

The issue of fault-tolerance with these logical opera-tions should be clear. The X,Z, H, P † and P gates aretrivially fault-tolerant since the logical operation is per-formed through seven bit-wise single qubit gates. Thelogical CNOT is also fault-tolerant since each two-qubitgate only operates between counterpart qubits in eachlogical block. Hence if any gate is inaccurate then, atmost, a single error will be introduced in each block.

In contrast to the [[7,1,3]] code, let us also take a quicklook at the [[5,1,3]] code. As mentioned in section VIIIthe [[5,1,3]] code is a non-CSS code, meaning that theClifford group of gates cannot be fully implemented in thesame way that we have illustrated for the 7-qubit code.To see this clearly we can examine how the generatorsof the stabilizer group for the code transforms under a

7

7

FIG. 13 Bit-wise application of a CNOT gate between twological qubits. Since each CNOT only couples correspond-ing qubits in each block, this operation is inherently fault-tolerant.

transversal Hadamard operation,

K1 = X Z Z X IK2 = I X Z Z XK3 = X I X Z ZK4 = Z X I X Z

H⊗5

−−−→Z X X Z II Z X X ZZ I Z X XX Z I Z X

(82)The stabilizer group is not preserved under this trans-formation and therefore is not a valid logical operationfor the [[5,1,3]] code. One thing to briefly note is thatthere are methods for performing logical Hadamard andphase gates on the [[5,1,3]] code (Got97). However, itessentially involves performing a valid, transversal, threequbit gate and then measuring out two of the logical an-cilla. Although it has been demonstrated that a validset of transversal operations for universal computing isincompatible with a quantum code that correct an arbi-trary single error (EK09), it has not been shown that anon-CSS code cannot have a transversal set of operationsgenerating the Clifford group. This example is used toillustrate the transformation for an invalid logical opera-tion on an encoded state.

While these gates can be conveniently implemented onerror protected data, they do not represent a universal setfor quantum computation. In fact it has been shown thatby using the stabilizer formalism, these operations can beefficiently simulated on a classical device (Got98; AG04).In order to achieve universality one of the following gatesare generally added to the available set,

T =

(1 00 eiπ/4

), (83)

or the Toffoli gate (Tof81). As neither of these two gatesare members of the Clifford group, applying them in asimilar way to the other gates will transform the sta-bilizers out the group and consequently does not rep-resent valid operations. Circuits implementing these

24

Ki ⊗Kj K1 K2 K3 K4 K5 K6

K1 K1 ⊗ I K1 ⊗K1K2 K1 ⊗K1K3 K1K4 ⊗K1K4 K1K5 ⊗K1K5 K1K6 ⊗K1K6

K2 K2 ⊗K1K2 K2 ⊗ I K2 ⊗K2K3 K2K4 ⊗K2K4 K2K5 ⊗K2K5 K2K6 ⊗K2K6

K3 K3 ⊗K3K1 K3 ⊗K3K2 K3 ⊗ I K3K4 ⊗K3K4 K3K5 ⊗K3K5 K3K6 ⊗K3K6

K4 K4 ⊗K1 K4 ⊗K2 K4 ⊗K3 I ⊗K4 K4K5 ⊗K5 K4K6 ⊗K6

K5 K5 ⊗K1 K5 ⊗K2 K5 ⊗K3 K5K4 ⊗K4 I ⊗K5 K5K6 ⊗K6

K6 K6 ⊗K1 K6 ⊗K2 K6 ⊗K3 K6K4 ⊗K4 K6K5 ⊗K5 I ⊗K6

TABLE VIII Transformations of the [[7, 1, 3]] stabilizer generators under the gate operation U =CNOT⊗7, where G → U†GU .Note that the transformation does not take any stabilizer outside the group generated by Ki ⊗Kj (i, j) ∈ [1, .., 6], thereforeU =CNOT⊗7 represents a valid operation on the codespace.

two gates in a fault-tolerant manner have been devel-oped (NC00; GC99; SI05; SFH08), but at this stage thecircuits are complicated and resource intensive. This haspractical implications to encoded operations. If univer-sality is achieved by adding the T gate to the list, arbi-trary single qubit rotations require long gate sequences(utilizing the Solovay-Kitaev theorem (Kit97; DN06)) toapproximate arbitrary logical qubit rotations and thesesequences often require many T gates (Fow05). Findingmore efficient methods to achieve universality on encodeddata is therefore still an active area of research.

XII. FAULT-TOLERANT CIRCUIT DESIGN FORLOGICAL STATE PREPARATION

Section X introduced the basic rules for fault-tolerantcircuit design and how these rules lead to the thresh-old theorem for concatenated error correction. However,what does a full fault-tolerant quantum circuit look like?Here, we introduce a full fault-tolerant circuit to preparethe [[7, 1, 3]] logical |0〉 state. As the [[7, 1, 3]] code is asingle error correcting code, we use the one-to-one defini-tion of fault-tolerance and therefore only need to considerthe propagation of a single error during the preparation(any more that one error during correction represents ahigher order effect and is ignored).

As described in Section VII, logical state preparationcan be done by initializing an appropriate number ofphysical qubits and measuring each of the X stabiliz-ers that describe the code. Therefore, a circuit whichallows the measurement of a Hermitian operator in afault-tolerant manner needs to be constructed. The gen-eral structure of the circuit used was first developed byShor (Sho96), however it should be noted that severalmore recent methods for fault-tolerant state preparationand correction now exist (Ste97a; Ste02; DA07; Kni05).

The circuits shown in Fig. 14a and 14b, which measurethe stabilizer K1 = IIIXXXX are not fault-tolerant,since a single ancilla is used to control each of the fourCNOT gates. As CNOT gates can copy X errors [Fig.11], a single X error on this ancilla can be copied tomultiple qubits in the data block. Instead, four an-cilla qubits are used which are prepared in the state|A〉 = (|0000〉+|1111〉)/

√2. This can be done by initializ-

ing four qubits in the |0〉 state and applying a Hadamard,

then a sequence of CNOT gates [Fig. 14c]. Each of thesefour ancilla are used to control a separate CNOT gate,after which the ancilla state is decoded and measured.By ensuring that each CNOT is controlled via a separateancilla, any X error will only propagate to a single qubitin the data block. However, during the preparation of theancilla state there is the possibility that a single X er-ror can propagate to multiple ancilla, which are then fedforward into the data block. In order to combat this, theancilla block needs to be verified against possible X er-rors. Tracking through all the possible locations where asingle X error can occur during ancilla preparation leadsto the following unique states.

|A〉1 =1√2

(|0000〉+ |1111〉),

|A〉2 =1√2

(|0100〉+ |1011〉),

|A〉3 =1√2

(|0010〉+ |1101〉),

|A〉4 =1√2

(|0001〉+ |1110〉),

|A〉5 =1√2

(|0111〉+ |1000〉),

|A〉6 =1√2

(|0011〉+ |1100〉),

(84)

From these possibilities, the first four states correspondto no error or at most one bit flip and the last two statescorrespond to multiple errors cased by errors copied bythe CNOT operations. In fact, only the last state, |A〉6,needs to be identified since two bit flip errors exist onthe ancilla state. To verify this ancilla state, a fifth an-cilla is added, initialized and used to perform a paritycheck on the ancilla block. This fifth ancilla is then mea-sured. If the result is |0〉, the ancilla block can be cou-pled to the data. If the ancilla result is |1〉, then eithera single error has occurred on the verification qubit orthe ancilla state has been prepared in either the |A〉5or |A〉6 state. In either case, the entire ancilla block isreinitialized and prepared again. This is continued untilthe verification qubit is measured to be |0〉 [Fig. 15].The re-preparation of the ancilla block protects againstmultiple X errors, which can propagate forward throughthe CNOT gates. Z errors propagate in the other di-

25

0

0

0 H

0

H M

H H M0H H M0

K1

a)

c)

b)

7

1

7

1

7

1

FIG. 14 Three circuits which measure the stabilizer K1. Subfigure a) represents a generic operator measurement where amulti-qubit controlled gate is available. Subfigure b) decomposes this into single- and two-qubit gates, but in a non-fault-tolerant manner. Subfigure c) introduces four ancilla such that each CNOT is controlled via a separate qubit. This ensuresfault-tolerance.

rection. Any Z error which occurs in the ancilla blockwill propagate straight through to the final measurement.This results in the measurement not corresponding tothe actual errors which have occurred and can result inmis-correction once all stabilizers have been measured.To protect against this, each stabilizer is measured 2-3times and a majority vote of the measurement resultstaken. As any additional error represents a second or-der process, if the first or second measurement has beencorrupted by a Z error, then the third measurement willonly contain additional errors if a higher order error pro-cess has occurred. Therefore, we are free to ignore thispossibility and assume that the third measurement is er-ror free. The full circuit for [[7, 1, 3]] state preparation isshown in Fig. 16, where each stabilizer is measured 2-3times. The total circuit requires a minimum of 12 qubits(7-data qubits and a 5-qubit ancilla block).

As you can see, the circuit constructions for full fault-tolerant state preparation (and error correction) are notsimple circuits. However, they are easy to design in

generic ways when employing stabilizer coding.

XIII. LOSS PROTECTION

So far we have focused the discussion on correctiontechniques which assume that error processes maintaina qubit structure to the Hilbert space. As we noted insection III.C, the loss of physical qubits within the com-puter violates this assumption and in general requiresadditional correction machinery beyond what we have al-ready discussed. This section examines a basic correctiontechniques for qubit loss. Specifically, we detail one suchscheme which was developed with single photon basedarchitectures in mind.

Protecting against qubit loss requires a different ap-proach than other general forms of quantum errors suchas environmental decoherence or systematic control im-perfections. The cumbersome aspect related to correct-ing qubit loss is detecting the presence of a qubit at the

26

H H M

M

Repeat Until M = 0

M

Mea

sure

K 1

7

1

M

FIG. 15 Circuit required to measure the stabilizer K1, fault-tolerantly. A four qubit GHZ state is used as ancilla with thestate requiring verification against multiple X errors. After the state has passed verification it is coupled to the data block anda syndrome is extracted.

physical level. The specific machinery that is required forloss detection is dependent on the underlying physical ar-chitecture, but the basic principal is that the presence orabsence of the physical qubit must be determined with-out discriminating the actual quantum state.

Certain systems allow for loss detection is a moreconvenient way than others. Electronic spin qubits,for example, can employ Single Electron Transistors(SET) to detect the presence or absence of the chargewithout performing measurement on the spin degree offreedom (DS00; CGJH05; AJW+01). Optics in con-trast requires more complicated non-demolition measure-ment (MW84; IHY85; POW+04; MNBS05). This is dueto the fact that typical photonic measurement is per-formed via photo-detectors which have the disadvantageof physically destroying the photon.

Once the detection of the presence of the physical qubithas been performed, a freshly initialized qubit can beinjected to replace the lost qubit. Once this has beencompleted, the standard error correcting procedure cancorrect for the error. A freshly initialized qubit state,|0〉 can be represented as projective collapse of a generalqubit state, |ψ〉, as,

|0〉 ∝ |ψ〉+ Z |ψ〉 . (85)

If we consider this qubit as part of an encoded block,then the above corresponds to a 50% error probability ofexperiencing a phase error on this qubit. Therefore, a lossevent that is corrected by non-demolition detection andstandard QEC essentially guarantees a correction eventin the QEC cycle. The probability of loss needs to be at acomparable rate to standard errors as the correction cycleafter a loss detection event will, with high probability,

detect an error.

If a loss event is detected and the qubit replaced, theerror detection code shown in section VI becomes a singleerror correction code. This is due to the fact that via theidentification of the loss event, these errors subsequentlyhave known locations. Consequently error detection issufficient to perform full correction, in contrast to the er-ror channels we have already considered where in generalthe location is unknown.

A second method for loss correction is related to sys-tems that have high loss rates compared to systematicand environmental errors, for example in optical systems.Due to the high mobility of single photons and their rel-ative immunity to environmental interactions, loss is amajor error channel that generally dominates over othererror sources. The use of error detection and correctioncodes for photon loss is undesirable due to the need fornon-demolition detection of the lost qubit. While tech-niques for measuring the presence or absence of a pho-ton without direct detection have been developed andimplemented (POW+04), they require multiple ancillaphotons and controlled interactions. Ultimately it ismay be more desirable to redesign the loss correctioncode such that it can be employed directly with photo-detection rather than more complicated non-demolitiontechniques (YNM06).

One such scheme was developed by Ralph, Hayes andGilchrist in 2005 (RHG05). This scheme was a moreefficient extension of an original parity encoding methoddeveloped by Knill, Laflamme and Milburn (KLM01).The general parity encoding for a logical qubit is an N

27

0 0

0 0

0

M

Measure K 1

0 0

0 0

0

Apply dotted boxes only if first tw

o results differ for each stabilizer.

Measure K 2

0

0

0

0 0

0

0

1

M

Z i

0

L

i = 1 +2 + 4 M M M

2 3 1

M

M

Measure K 1

1

M

M

Measure K 1

1

M

M2

Measure K 2 M

M2

Measure K 2 M

M2

M

3M

Measure K 3

M

3M

Measure K 3

M

3M

Measure K 3

FIG. 16 Circuit required to prepare the [[7, 1, 3]] logical |0〉 state fault-tolerantly. Each of the X stabilizers are sequentiallymeasured using the circuit in Fig. 15. To maintain fault-tolerance, each stabilizer is measured 2-3 times with a majority votetaken.

28

photon GHZ state in the conjugate basis, i.e,

|0〉NL =1√2

(|+〉⊗N + |−〉⊗N ),

|1〉NL =1√2

(|+〉⊗N − |−〉⊗N ),

(86)

where |±〉 = (|0〉 ± |1〉)/√

2. The motivation with thistype of encoding is that measuring any qubit in the |0, 1〉basis simply removes it from the state, reducing the re-sulting state by one,

P0,N |0〉NL = (IN + ZN ) |0〉NL=

1√2

(|+〉N−1+ |−〉N−1

) |0〉N = |0〉N−1L |0〉N ,

P1,N |0〉NL = (IN − ZN ) |0〉NL=

1√2

(|+〉N−1 − |−〉N−1) |1〉N = |1〉N−1

L |1〉N ,(87)

where P(0,1),N are the projectors corresponding to mea-surement in the |0, 1〉 basis on the N -th qubit (up tonormalization). The effect for the |1〉L state is similar.Measuring the N -th qubit in the |0〉 state simply removesit from the encoded state, reducing the logical zero stateby one, while measuring the N -th qubit as |1〉 enacts alogical bit flip at the same time as reducing the size ofthe logical state.

Instead of introducing the full scheme developedin (RHG05), we instead give the general idea of how suchencoding allows for loss detection without non-demolitionmeasurements. Photon loss in this model is assumedequivalent to measuring the photon in the |0〉 , |1〉 basis,but not knowing the answer [Sec III.C]. Our ignoranceof the measurement result could lead to a logical bit-fliperror on the encoded state, therefore we require the abil-ity to protect against logical bit-flip errors on the abovestates. As already shown, the 3-qubit code allows us toachieve such correction. Therefore the final step in thisscheme is encoding the above states into a redundancycode (a generalized version of the 3-qubit code), wherean arbitrary logical state, |ψ〉L is now given by,

|ψ〉L = α |0〉N1 |0〉N2 ... |0〉Nq + β |1〉N1 |1〉

N2 ... |1〉Nq (88)

where |0〉N , |1〉N are the parity encoded states shown inEq. (87) and the fully encoded state is q-blocks of theseparity states.

This form of encoding protects against the loss ofqubits by first encoding the system into a code structurethat allows for the removal of qubits without destroy-ing the computational state and then protecting againstlogical errors that are induced by loss events. In effect,it maps errors un-correctable by standard QEC to errorchannels that are correctable, in this case qubit loss →qubit bit-flip. Even though this code can be used to con-vert loss events into bit-flips, the size of the code willsteadily decrease as qubits are lost.

This general technique is common with pathological er-ror channels. If a specific type of error violates the stan-dard “qubit” assumption of QEC, additional correctiontechniques are always required to map this type of errorto a correctable form, consequently additional physicalresources are usually needed.

XIV. SOME MODERN DEVELOPMENTS IN QUANTUMERROR CORRECTION

Up until this stage we have restricted our discussionson error correction to the most basic principals and codes.The ideas and methodologies we have detailed representsome of the introductory techniques that were developedwhen error correction was first proposed. For readerswho are only looking for a basic introduction to the field,you can quite easily skip the remainder of this paper aswe will now examine some of the more modern protocolsthat are utilized when considering the construction of alarge scale quantum computer.

Providing a fair and encompassing review of the moremodern and advanced error correction techniques thathave been developed is far outside our goal for this re-view. However, we would be remiss if we did not brieflyexamine some of the more advanced error correction tech-niques that have been proposed for large scale quantuminformation processing. For the remainder of this discus-sion we choose two closely related error correction tech-niques, subsystem coding and topological coding whichhave been receiving significant attention in the fields ofarchitecture design and large scale quantum informationprocessing. While some readers may disagree, we reviewthese two modern error correction protocols because theyare currently two of the most useful correction techniqueswhen discussing the physical construction of a quantumcomputer.

We again attempt to keep the discussion of these tech-niques simple and provide specific examples when pos-sible. However, it should be stressed that these errorcorrecting protocols are far more complicated than thebasic codes shown earlier. Topological error correctionalone has, since its introduction, essentially become itsown research topic within the broader error correctionfield. Hence we encourage the reader who is interestedto refer to the cited articles below for more rigorous anddetailed treatment of these techniques.

A. Subsystem codes: Bacon-Shor codes

Quantum subsystem codes (KLP05; KLPL06; Bac06)are one of the newer and highly flexible techniques to im-plement quantum error correction. The traditional sta-bilizer codes that we have reviewed are more formallyidentified as subspace codes, where information is en-coded in a relevant coding subspace of a larger multi-qubit system. In contrast, subsystem coding identifies

29

multiple subspaces of the multi-qubit system as equiva-lent. Specifically, multiple states are identified with thelogical |0〉L and |1〉L states. Rather than review the sub-system codes in general, we will focus on a subset of thesecodes known as Bacon-Shor codes (Bac06).

The primary benefit to utilizing Bacon-Shor (BS)codes is the general nature of their construction. Thedescription of arbitrarily large error correcting codesis conceptually straightforward, error correction circuitsare much simpler to construct (AC07), and the gen-erality of their construction introduces the ability toperform dynamical code switching in a fault-tolerantmanner (SEDH08). This final property gives BS cod-ing significant flexibility as the strength of error correc-tion within a quantum computer can be changed fault-tolerantly during operation of the computer.

As with the other codes presented in this review, BScodes are stabilizer codes but now defined over a squarelattice. The lattice dimensions represent the X and Zerror correction properties and the size of the lattice ineither of these two dimensions dictates the total numberof errors the code can correct. In general, a C(n1,n2)BS code is defined over a n1 × n2 square lattice whichencodes one logical qubit into n1n2 physical qubits withthe ability to correct at least bn1−1

2 c Z errors and at

least bn2−12 c X errors. Again, keeping with the spirit of

this review, we focus on a specific example, the C(3,3)BS code. This code, encoding one logical qubit with 9physical qubits can correct for one X and one Z error.In order to define the code structure we begin with a3 × 3 lattice of qubits, where qubits are identified withthe vertices of the lattice. Note that this 2D structurerepresents the structure of the code, it does not implythat a physical array of qubits must be arranged intoa 2D lattice. Fig. 17 illustrate three sets of stabilizeroperators which are defined over the lattice. The firstgroup, illustrated in Fig. 17a. is the stabilizer group, S,which is generated by the operators,

S = 〈Xi,∗Xi+1,∗;Z∗,jZ∗,j+1 | i ∈ Z2; j ∈ Z2〉, (89)

where we retain the notation utilized in (AC07;SEDH08). Ui,∗ and U∗,j represent an operator, U , actingon all qubits in a given row, i, or column, j, respectively,and Z2 = {1, 2}. The second relevant subsystem is knownas the gauge group [Fig. 17b.], T , and is described via thenon-Abelian group generated by the pairwise operators

T = 〈Xi,jXi+1,j ;Zj,iZj,i+1 | i ∈ Z2; j ∈ Z3〉, (90)

The third relevant subsystem is the logicalspace [Fig. 17c], L, which can be defined throughthe logical Pauli operators

L = 〈Z∗,1;X1,∗〉. (91)

The stabilizer group S, defines all relevant code states,i.e. every valid logical space is a +1 eigenvalue of thisset. For the C(3,3) code, there are a total of nine physi-cal qubits and a total of four independent stabilizers in S,

X X X

X X X

Z

Z

Z

Z

Z

Z

X

Z

X

Z

Y

Y

X X X Z

Z

Z

a)

b)

c)

FIG. 17 Stabilizer structure for the C(3,3) code. Subfigure a)gives two of the four stabilizers from the group S. Subfigure b)illustrates one of the four encoded sets of Pauli operators fromeach subsystem defined with the Gauge group, T . Subfigurec) gives the two logical operators from the group L whichenact valid operations on the encoded qubit.

hence there are five degrees of freedom left in the systemwhich can house 25 logical states which are simultaneouseigenstates of S. This is where the gauge group, T , be-comes relevant. As the gauge group is non-Abelian, thereis no valid code state which is a simultaneous eigenstateof all operators in T . However, if you examine closelythere are a total of four encoded sets of Pauli operationswithin T . Fig 17b. illustrates two such sets. As allelements of T commute with all elements of S we canidentify each of these four sets of valid “logical” qubitsto be equivalent, i.e. we define {|0〉L , |1〉L} pairs whichare eigenstates of S and one abelian subgroup of T andthen ignore exactly what gauge group we are in8. There-fore, each of these gauge states represent a subsystem ofthe code, with each subsystem logically equivalent.

The final group we consider is the logical group L. Thisis the set of two Pauli operators which enact a logical X

8 Provided we are in eigenstates of S we can, in principal, be insuperpositions of eigenstates of the operators in T . However, theerror correction procedure for the BS code projects us back toeigenstates of the gauge operators.

30

or Z gate on the encoded qubit regardless of the gaugechoice and consequently represent true logical operationsto our encoded space.

In a more formal sense, the definition of these threegroup structures allows us to decompose the Hilbertspace of the system. If we let H denote the Hilbert spaceof the physical system, S forms an Abelian group andhence can act as a stabilizer set defining subspaces of H.If we describe each of these subspaces by the binary vec-tor, ~e, formed from the eigenvalues of the stabilizers, S,then each subspace splits into a tensor product structure

H =⊕~e

HT ⊗HL, (92)

where elements of T act only on the subsystem HT andthe operators L act only on the subsystem HL. In thecontext of storing qubit information, a logical qubit isencoded into the two dimensional subsystem HL. As thesystem is already stabilized by operators in S and theoperators in T act only on the space HT , qubit informa-tion is only altered when operators in the group L act onthe system.

This formal definition of how BS coding works maybe more complicated than the standard stabilizer codesshown earlier, but this slightly more complicated codingstructure has significant benefits when we consider howerror correction is performed.

In general, to perform error correction, each of thestabilizers of the codespace must be checked to deter-mine which eigenvalue changes have occurred due to er-rors. The stabilizer group, S, consist of qubit operatorsthat scale with the size of the code. In general, for an1 × n2 lattice, the X stabilizers are 2n1 dimensionaland the Z stabilizers are 2n2 dimensional. If techniquessuch as Shor’s method [Section XII] were used, we wouldneed to prepare a large ancilla state to perform fault-tolerant correction, this is clearly undesirable. This prob-lem can be mitigated due to the gauge structure of thesecodes (AC07).

Each of the stabilizers in S are simply the product ofcertain elements from T , for example,

X1,1X1,2X1,3X2,1X2,2X2,3 ∈ S=(X1,1X2,1).(X1,2X2,2).(X1,3X2,3) ∈ T . (93)

Therefore if we check the eigenvalues of the three, 2-qubitoperators from T we are able to calculate what the eigen-value is for the 6-dimensional stabilizer. This decompo-sition of the stabilizer set for the code can only occursince the decomposition is in terms of operators from Twhich, when measured, has no effect on the logical infor-mation encoded within the system. In fact, when errorcorrection is performed, the gauge state of the systemwill almost always change based on the order in whichthe eigenvalues of the gauge operators are checked.

This exploitation of the gauge properties of subsys-tem coding is extremely beneficial for the design of fault-tolerant correction circuits. As the stabilizer operators

can now be decomposed into multiple 2-dimensional op-erators, fault-tolerant circuits for error correction do notrequire any encoded ancilla states. Furthermore, even ifwe decide to scale the code-space to correct more errors(increasing the lattice size representing the code), we donot require measuring operators with higher dimension-ality. Fig 18 taken from Ref. (AC07) illustrates the fault-tolerant circuit constructions for Bacon-Shor subsystemcodes. As each ancilla qubit is only coupled to two data

(a) (b)j, k ��������j+1, k ��������|+〉 • • H FE

k, j•

k, j+1 •

|0〉 �������� �������� FE FIG. 18 (From Ref. (AC07)) Circuits for measuring thegauge operators and hence performing error correction forsubsystem codes. Subfigure a) measures, fault-tolerantly, theoperator Xj,kXj+1,k with only one ancilla. Subfigure b) mea-sures Zk,jZk,j+1. The results of these two qubit parity checkscan be used to calculate the parity of the higher dimensionalstabilizer operators of the code.

qubits, no further circuit constructions are required toensure fault-tolerance9. The measurement results fromthese 2-dimensional parity checks are then combined tocalculate the parity of the higher dimensional stabilizerof the subsystem code.

A second benefit to utilizing subsystem codes is theability to construct fault-tolerant circuits to perform dy-namical code switching. Dynamical code switching is atechnique that could be utilized when noise sources arehighly biased. In many systems the physical mechanismswhich lead to errors are not symmetric in X and Z. Forexample, simple Markovian dephasing introduces only Zerrors into the system and in all circumstances is themore dominant error channel.

One technique is to use concatenation in a clever way.The QEC codes we have largely examined in this revieware symmetric in the X and Z sector. The 5-, 7- and 9-qubit codes correct for one X error and one Z error. Al-iferis and Preskill considered a concatenated code, wherethe lower level code is a simple n qubit repetition code[Section IV] that only corrected for Z errors (AP08). Byutilizing this lower level code, they symmeterize the Zand X noise (the size of the n qubit code is determinedby the level of asymmetry in the physical noise). Thesubsequent levels are standard QEC codes, but it nowoperates at the next encoded level which will operatewith symmetrical rates for logical X and Z errors. Byutilising the simpler n-qubit repetition code at the lower

9 It should be noted that for higher distance BS codes, specificallyfor d ≥ 5, multiple measurements for each syndrome are requiredto ensure fault-tolerance

31

level, qubit resources are reduced, compared to using asymmetric code at every level. This work was extendedand adapted to a realistic model in superconducting sys-tems (ABD+09).

Asymmetric coding may also be required if the noiseacting on a quantum computer changes over the courseof its operation. In this case it may be require to switchfrom a symmetric code to a asymmetric code, dynami-cally. Naively, this can be done be simply decoding allqubits and then re-encoding them with the new code.However, this procedure would not be fault-tolerant, asany error that occurs to the system when it is decodedwill propagate through to the new encoded state. A sec-ond technique would be to encode the system with anasymmetric code at the next level of concatenation andthen decode the lower level. However, when utilizing theBS codes, we can perform this code switching in a dif-ferent way. As noted before, the C(n1, n2) code correctsfor bn1−1

2 c X errors and bn1−12 c Z errors. The ability to

convert between two codes, C(n1, n2) and C(n′1, n′2), in afault-tolerant manner would allow for us to dynamicallychange the strength (or asymmetry) of the error correc-tion whenever noise rates fluctuate in the computer. Itwas shown in Ref. (SEDH08) how such switching can beachieved, allowing for the fault-tolerant conversion be-tween arbitrary sized QEC codes.

B. Topological codes

A similar coding technique to the Bacon-Shor subsys-tem codes is the idea of topological error correction, firstintroduced with the Toric code of Kitaev in 1997 (Kit97).Topological coding is similar to subsystem codes in thatthe code structure is defined on a lattice (which, in gen-eral, can be of dimension ≥ 2) and the scaling of thecode to correct more errors is conceptually straightfor-ward. However, in topological coding schemes the pro-tection afforded to logical information relies on the un-likely application of error chains which define non-trivialtopological paths over the code surface.

Topological error correction is a complicated area ofQEC and fault-tolerance and any attempt to fairly sum-marize the field is not possible within this review. Inbrief, there are two ways of approaching these schemes.The first is simply to treat topological codes as a classof stabilizer codes over a qubit system. This approachis more amenable to current information technologiesand is being adapted to methods in cluster state com-puting (RHG07; FG09), optics (DFS+09; DMN08), ion-traps (SJ09) and superconducting systems (IFI+02). Thesecond approach is to construct a physical Hamiltonianmodel based on the structure of the topological code orchoose systems which appear to exhibit topological or-der. This leads to the more complicated field on anyonicquantum computation (Kit97). By translating a cod-ing structure into a physical Hamiltonian system, excita-tions from the ground state of this Hamiltonian exhibit

natural robustness against local errors (since their phys-ical Hamiltonian symmetries reflect the coding structureimposed). Specifically, quasi-particles arising from theHamiltonian approach exhibit fractional quantum statis-tics (they acquire fractional phase shifts when their posi-tions are exchanged twice with other anyons, in contrastto Bosons or Fermions which always acquire ±1 phaseshifts). The unique properties of anyons therefore allowfor natural, robust, error protection and anyon-anyon in-teractions are performed by rotating anyons around eachother. However, the major issue with this model is thatit relies on quasi-particle excitations that do not, in gen-eral, arise naturally. Although certain physical systemshave been shown to exhibit anyonic excitations, most no-tably in the fractional quantum hall effect (NSS+08).However, it is a daunting task to both manufacture areliable anyonic system and to reliably design and con-struct a large scale computing system. Note: Recentlyit has been shown that anyonic models based on the2D codes illustrated in this section do not exhibit self-correcting properties (KC08; BT09). Higher dimensionaltopological coding models, minimum of 4D, are actuallyrequired to implement self-correcting quantum memo-ries (AHHH10).

As there are several extremely good discussions of bothanyonic (NSS+08) and non-anyonic topological comput-ing (DKLP02; FSG09; FG09), we will not review anyof the anyonic methods for topological computing andsimply provide a brief example of one topological cod-ing scheme, namely the surface code (BK01; DKLP02;FSG09). The surface code for QEC is a desirable er-ror correction model for several reasons. As it is de-fined over a 2-dimensional lattice of qubits it can beimplemented on architectures that only allow for thecoupling of nearest neighbour qubits (rather than thearbitrary long distance coupling of qubits in separateregions of the computer). The surface code also ex-hibits one of the highest fault-tolerant thresholds of anyQEC scheme, recent simulations estimate a threshold ap-proaching 1% (RHG07; WFSH10). Finally, the surfacecode can correct problematic error channels such as qubitloss and leakage naturally (SBD09).

The surface code, as with subsystem codes, is a stabi-lizer code defined over a 2-dimensional qubit lattice, asFig. 19 illustrates. We identify each edge of the 2D latticewith a physical qubit. The stabilizer set consists of twotypes of operators. The first is the set of Z⊗4 operatorswhich circle every lattice face (or plaquette). The secondis the set of X⊗4 operators which encircle every vertex ofthe lattice. The stabilizer set is consequently generatedby the operators,

Ap =⊗j∈b(p)

Zj , Bv =⊗j∈s(v)

Xj , (94)

where b(p) is the four qubits surrounding a plaquette ands(v) is the four qubits surrounding each vertex in thelattice and identity operators on the other qubits are im-plied. First note that all of these operators commute

32

as any plaquette and vertex stabilizer will share eitherzero or two qubits. If the lattice is not periodic in ei-ther dimension, this stabilizer set completely specifies oneunique state, i.e. for a N×N lattice there are 2N2 qubitsand 2N2 stabilizer generators. Hence this stabilizer setdefines a unique multi-qubit entangled state which is gen-erally referred to as a “clean” surface. Detailing exactly

XX

X

XZ

Z

ZZ

Bv

Ap Ap ApAp

Ap Ap ApAp

Ap Ap ApAp

Ap Ap ApAp

BvBv

Bv BvBv

Bv BvBv

Qubits

FIG. 19 General structure of the surface code. The edgesof the lattice correspond to physical qubits. The four qubitssurrounding each face (or plaquette) are +1 eigenstates of theoperators Ap while the four qubits surrounding each vertexare +1 eigenstates of the operators Bv. If all eigenstate con-ditions are met, a unique multi-qubit state is defined as a“clean” surface.

how this surface can be utilized to perform robust quan-tum computation is far outside the scope of this reviewand there are several papers to which such a discussioncan be referred (RH07; RHG07; FSG09; FG09). Instead,we can quite adequately show how robust error correctionis possible by simply examining how a “clean” surface canbe maintained in the presence of errors. The X and Zstabilizer sets, Ap and Bv define two equivalent 2D lat-tices which are interlaced, as Fig. 20, illustrates. If thetotal 2D lattice is shifted along the diagonal by half a cellthen the operators Bv are now arranged around a plaque-tte and the operators Ap are arranged around a latticevertex. Since protection against X errors are achieved bydetecting eigenvalue flips of Z stabilizers and visa-versa,these two interlaced lattices correspond to error correc-tion against X and Z errors respectively. Therefore wecan quite happily restrict our discussion to one possibleerror channel, for example correcting X errors (since thecorrection for Z errors proceeds identically when consid-ering the stabilizers Bv instead of Ap).

Fig 21a. illustrates the effect a single X error hason a pair of adjacent plaquettes. Since X and Z anti-

commute, a single bit-flip error on one qubit in the sur-face will flip the eigenvalue of the Z⊗4 stabilizers on thetwo plaquettes adjacent to the respective qubit. As singlequbit errors act to flip the eigenvalue of adjacent plaque-tte stabilizers we examine how chains of errors affect thesurface. Figs 21b. and Fig. 21c. examine two longerchains of errors. As you can see, if multiple errors occur,only the eigenvalues of the stabilizers associated with theends of the error chains flip. Each plaquette along thechain will always have two X errors occurring on differentboundaries and consequently the eigenvalue of the Z⊗4

stabilizer around these plaquettes will flip twice.

If we now consider an additional ancilla qubit whichsits in the center of each plaquette and can couple tothe four surrounding qubits, we can check the parity byrunning the simple circuit shown in Fig 22. If we as-sume that we initially prepare a perfect “clean” surfacewe then, at some later time, check the parity of everyplaquette over the surface. If X errors have occurred ona certain subset of qubits, the parity associated with theendpoints of error chains will have flipped. We now takethis 2-dimensional classical data tree of eigenvalue flipsand pair them up into the most likely set of error chains.Since it is assumed that the probability of error on anyindividual qubit is low, the most likely set of errors whichreflects the eigenvalue changes observed is the minimumweight set (i.e. connect up all plaquettes where eigenval-ues have changed into pairs such that the total length ofall connections is minimized). This classical data process-ing is quite common in computer science and minimumweight matching algorithms such as the Blossom pack-age (CR99; Kol09) have a running time polynomial inthe total number of data points in the classical set. Oncethis minimal matching is achieved, we can identify thelikely error chains corresponding to the end points andcorrection can be applied accordingly.

The failure of this code is therefore dictated by errorchains that cannot be detected through changes in pla-quette eigenvalues. If you examine Fig 23, we consideran error chain that connects one edge of the surface lat-tice to another. In this case every plaquette has twoassociated qubits that have experienced a bit flip and noeigenvalues in the surface have changed. Since we haveassumed that we are only wishing to maintain a “clean”surface, these error chains have no effect, but when oneconsiders the case of storing information in the lattice,these types of error chains correspond to logical errorson the qubit (FSG09). Hence undetectable errors arechains which connect boundaries of the surface to otherboundaries (in the case of information processing, qubitsare artificial boundaries within the larger lattice surface).It should be stressed that this is a simplified descriptionof the full protocol, but it does encapsulate the basicidea. The important thing to realize is that the failurerate of the error correction procedure is suppressed, ex-ponentially with the size of the lattice. If we consideran error model where each qubit experiences a bit flip,independently, with probability p, then an error chain of

33

XX

X

XZ

Z

ZZ

Bv

Ap Ap ApAp

Ap Ap ApAp

Ap Ap ApAp

Ap Ap ApAp

BvBv

Bv BvBv

Bv BvBv

XX

X

XZ

Z

ZZ

Bv

Ap Ap ApAp

Ap Ap ApAp

Ap Ap ApAp

Ap Ap ApAp

BvBv

Bv BvBv

Bv BvBv

Shift Lattice

FIG. 20 The surface code imbeds two self similar lattices that are interlaced, generally referred to as the primal and duallattice. Subfigure a) illustrates one lattice where plaquettes are defined with the stabilizers Ap. Subfigure b) illustrates the dualstructure where plaquettes are now defined by the stabilizer set Bv. The two lattice structures are interlaced and are relatedby shifting along the diagonal by half a lattice cell. Each of these equivalent lattices are independently responsible for X andZ error correction.

XX X X XX

b) c)a)

FIG. 21 Examples of error chains and their effect on the eigenvalues for each plaquette stabilizer. Subfigure a). A single Xerror causes the parity of two adjacent cells to flip. Subfigures b) and c). Longer chains of errors only cause the end cells toflip eigenvalue as each intermediate cell will have two X errors and hence the eigenvalue for the stabilizer will flip twice.

one occurs with probability p, error chains of weight twooccur with probability O(p2), chains of three O(p3) etc.If we have an N × N lattice and we extend the surfaceby one plaquette in each dimension, then the probabilityof having an error chain connecting two boundaries willdrop by a factor of p (one extra qubit has to experiencean error). Extending an N ×N lattice by one plaquettein each dimension requires O(N) extra qubits, hence thistype of error correcting code suppresses the probabilityof having undetectable errors exponentially with a qubitresource cost which grows linearly.

As we showed in Section X, standard concatenatedcoding techniques allow for a error rate suppression whichscales with the concatenation level as a double exponen-tial while the resource increase scales exponentially. Forthe surface code, the error rate suppression scales ex-ponentially while the resource increase scales linearly.While these scaling relations might be mathematically

equivalent, the surface code offers much more flexibilityat the architectural level. Being able to increase the errorprotection in the computer with only a linear change inthe number of physical qubits is far more beneficial thanusing an exponential increase in resources when utilizingconcatenated correction. Specifically, consider the casewhere a error protected computer is operating at a logi-cal error rate which is just above what is required for analgorithm. If concatenated error correction is employed,then adding another later of correction will not only in-crease the number of qubits by an exponential amount,but it will also drop the effective logical error rate farbelow what is actually required. In contrast, if surfacecodes are employed, we increase the qubit resources bya linear factor and drop the logical error rate sufficientlyfor successful application of the algorithm.

We now leave the discussion regarding topological cor-rection models. We emphasize again that this was a

34

Z

Z

Z

Z

H H M

|ψ〉1..4

|0〉b)

a)

FIG. 22 Subfigure a). Lattice structure to check the parityof a surface plaquette. An additional ancilla qubit is coupledto the four neighboring qubits that comprise each plaquette.Subfigure b). Quantum circuit to check the parity of the Z⊗4

stabilizer for each surface plaquette.

X

X

X

X

X X

X

X

X X

FIG. 23 Example of a chain of errors which do not cause anyeigenvalue changes in the surface. If errors connect bound-aries to other boundaries, the error correction protocol willnot detect them. In the case of a “clean” surface, these errorchains are invariants of the surface code. When computa-tion is considered, qubit information are artificial boundarieswithin the surface. Hence if error chains connect these infor-mation qubits to other boundaries, logical errors occur.

very broad overview of the general concept of topolog-ical codes. There are many details and subtleties thatwe have deliberately left out of this discussion and weurge the reader, if interested, to refer to the referencedarticles for a more thorough treatment of this topic.

XV. CONCLUSIONS AND FUTURE OUTLOOK

This review has hopefully provided a basic introduc-tion to some of the most important theoretical aspects ofQEC and fault-tolerant quantum computation. The ul-timate goal of this discussion was not to provide a rigor-ous theoretical framework for QEC and fault-tolerance,but instead attempted to illustrate most of the impor-tant rules, results and techniques that have evolved outof this field. Hopefully this introduction will serve asa starting point for individuals introducing themselvesto this topic. For those wishing to continue researchinto the QEC field, we highly recommend consulting thepapers referenced throughout this review and especiallyRefs. (Got97; NC00; Got02; KLA+02; Ste01; Got09)which provide a more mathematically rigorous review ofQEC and fault-tolerance.

We not only covered the basic aspects of QEC throughspecific examples, but also we have briefly discussed howphysical errors influence quantum computation and howthese processes are interpreted within the context ofQEC. One of the more important aspects of this review isthe discussion related to the stabilizer formalism, circuitsynthesis and fault-tolerant circuit construction. Stabi-lizers are arguably the most useful theoretical formalismin QEC as once it is sufficiently understood, most of theimportant properties of error correcting codes can be in-vestigated and understood largely by inspection.

The study of QEC and fault-tolerance is still and activearea of QIP research. Although the library of quantumcodes and error correction techniques are vast there isstill a significant disconnect between the abstract frame-work of quantum coding and the more physically realisticimplementation of error correction for large-scale quan-tum information processing.

There are several future possibilities for the direction ofquantum information processing. Even with the develop-ment of many of these advanced techniques, the physicalconstruction and accuracy of current qubit fabrication isstill insufficient to obtain any benefit from QEC. Manyin the field now acknowledge that the future developmentof quantum computation will most likely split into twobroad categories. The first is arguably the more physi-cally realistic, namely small qubit applications in quan-tum simulation. Beyond these smaller qubit applications,we move to truly large scale quantum computation, i.e.implementing large algorithms such as Shor on qubit ar-rays well beyond 1000 physical qubits. This would un-doubtably require active techniques in error correction.Future work needs to focus on adapting the many codesand fault-tolerant techniques to the architectural level.As we noted in section X.C, the implementation of QECat the design level largely influences the fault-tolerantthreshold exhibited by the code itself. Being able to ef-ficiently incorporate both the actual quantum code andthe error correction procedures at the physical level isextremely important when developing an experimentallyviable, large-scale quantum computer.

35

There are many differing opinions within the quan-tum computing community as to the future prospectsfor quantum information processing. Many remain pes-simistic regarding the development of a million qubit de-vice and instead look towards quantum simulation in theabsence of active error correction as the realistic goal ofquantum information. However, in the past few years,the theoretical advances in error correction and the fan-tastic speed in the experimental development of few qubitdevices continues to offer hope for the near-term con-struction of a large scale computer, incorporating manyof the ideas presented within this review. While we couldnever foresee the possible successes or failures in quan-tum information science, we remain hopeful that a largescale quantum computer is still a goal worth pursuing.

XVI. ACKNOWLEDGMENTS

The authors wish to thank A. M. Stephens, R. VanMeter, A.G. Fowler, L.C.L. Hollenberg, A. D. Greentreefor helpful comments and acknowledge the support ofMEXT, JST and FIRST projects.

References

[ABD+09] P. Aliferis, F. Brito, D.P. DiVincenzo, J. Preskill,M. Steffen, and B.M. Terhal. Fault-Tolerant Comput-ing With Biased-Noise Superconducting Qubits. New. J.Phys., 11:013061, 2009.

[ABO97] D. Aharonov and M. Ben-Or. Fault-tolerant Quan-tum Computation with constant error. Proceedings of29th Annual ACM Symposium on Theory of Computing,page 46, 1997.

[AC07] P. Aliferis and A.W. Cross. Subsystem fault tolerancewith the Bacon-Shor code. Phys. Rev. Lett., 98:220502,2007.

[AG04] S. Aaronson and D. Gottesman. Improved Simulationof Stabilizer Circuits. Phys. Rev. A., 70:052328, 2004.

[AHHH10] R. Alicki, M. Horodecki, P. Horodecki, andR. Horodecki. On thermal Stability of topological qubitin Kitaev’s 4D Model. Open Syst. Inf. Dyn., 17:1, 2010.

[AJW+01] A. Aassime, G. Johansson, G. Wendin, R.J.Schoelkopf, and P. Delsing. Radio-Frequency Single-Electron Transistor as Readout Device for Qubits: ChargeSensitivity and Backaction. Phys. Rev. Lett., 86:3376,2001.

[Ali07] P. Aliferis. PhD Thesis (Caltech), 2007.[ALKH02] D. Ahn, J. Lee, M.S. Kim, and S.W. Hwang. Self-

Consistent non-Markovian theory of a quantum-state evo-lution for quantum-information-processing. Phys. Rev. A.,66:012302, 2002.

[AP08] P. Aliferis and J. Preskill. Fault-Tolerant quan-tum computation against biased noise. Phys. Rev. A.,78:052331, 2008.

[APN+05] O. Astafiev, Yu. A. Pashkin, Y. Nakamura, T. Ya-mamoto, and J.S. Tsai. Quantum Noise in the JosephsonCharge Qubit. Phys. Rev. Lett., 93:267007, 2005.

[ATK+09] T. Aoki, G. Takahashi, T. Kajiya, J. Yoshikawa,S.L. Braunstein, P. van Loock, and A. Furusawa. Quan-

tum Error Correction Beyond Qubits. Nature Physics(London), 5:541, 2009.

[Avi87] A. Avizienis. The Evolution of Fault-Tolerant Com-puting. Springer -Verlag, New York, 1987.

[Bac06] D. Bacon. Operator Quantum Error-Correcting Sub-systems for self-correcting quantum memories. Phys. Rev.A., 73:012340, 2006.

[BBK03] A. Bririd, S.C. Benjamin, and A. Kay. Quan-tum error correction in globally controlled arrays. quant-ph/0308113, 2003.

[BHC04] K. R. Brown, A.W. Harrow, and I.L. Chuang. Ar-bitrarily accurate composite pulse sequences. Phys. Rev.A., 70:052318, 2004.

[BHPC03] N. Boulant, T.F. Havel, M.A. Pravia, and D.G.Cory. Robust Method for Estimating the Lindblad opera-tors of a dissipative quantum process from measurementsof the density operator at multiple time points. Phys. Rev.A., 67:042322, 2003.

[BK01] S.B. Bravyi and A.Y. Kitaev. Quantum codes on alattice with boundary. Quant. Computers and Computing,2:43, 2001.

[BKD04] G. Burkard, R.H. Koch, and D.P. DiVincenzo. Mul-tilevel quntum description of decoherence in supercon-ducting qubits. Phys. Rev. B., 69:064503, 2004.

[BKSO05] S. Balensiefer, L. Kregor-Stickles, and M. Oskin.An Evaluation Framework and Instruction Set Architec-ture for Ion-Trap based Quantum Micro-architectures.SIGARCH Comput. Archit. News, 33:186, 2005.

[BLWZ05] M.S. Byrd, D.A. Lidar, L.-A. Wu, and P. Zanardi.Universal leakage elimination. Phys. Rev. A., 71:052301,2005.

[BM03] S.D. Barrett and G.J. Milburn. Measuring the Deco-herence rate in a semiconductor charge qubit. Phys. Rev.B., 68:155307, 2003.

[BMD06] H. Bombin and M.A. Martin-Delgato. TopologicalQuantum Distillation. Phys. Rev. Lett., 97:180501, 2006.

[BMD07a] H. Bombin and M.A. Martin-Delgato. OptimalResources for Topological 2D Stabilizer Codes: Compara-tive Study. Phys. Rev. A., 76:012305, 2007.

[BMD07b] H. Bombin and M.A. Martin-Delgato. Topolog-ical Computation without Braiding. Phys. Rev. Lett.,98:160502, 2007.

[BR01] H.-J. Briegel and R. Raussendorf. Persistent Entan-glement in Arrays of Interacting Particles. Phys. Rev.Lett., 86:910, 2001.

[Bra98] S.L. Braunstein. Error Correction for continuousquantum variables. Phys. Rev. Lett., 80:4084, 1998.

[BSW96] C.H. Bennett, D.P. DiVincenzo J.A. Smolin, andW.K. Wooters. Mixed State Entanglement and QuantumError Correction. Phys. Rev. A., 54:3824, 1996.

[BT09] S. Bravyi and B.M. Terhal. A no-go theorem for atwo-dimensional self-correcting quantum memory basedon stabilizer codes. New. J. Phys., 11:043029, 2009.

[CG97] R. Cleve and D. Gottesman. Efficient Computationsof Encodings for Quantum Error Correction. Phys. Rev.A., 56:76, 1997.

[CGJH05] V.I. Conrad, A.D. Greentree, D.N. Jamieson, andL.C.L. Hollenberg. Analysis and Geometric Optimizationof Single Electron Transistors for Read-Out in Solid-StateQuantum Computing. Journal of Computational and The-oretical Nanoscience, 2:214, 2005.

[CR99] W. Cook and A. Rohe. Computing minimum-weightperfect matchings. INFORMS Journal on Computing,,11:138, 1999.

36

[CRSS98] A.R. Calderbank, E.M. Rains, P.W. Shor, andN.J.A. Sloane. Quantum Error Correction via Codes OverGF(4). IEEE Trans. Inform. Theory, 44:1369, 1998.

[CS96] A.R. Calderbank and P.W. Shor. Good QuantumError-Correcting codes exist. Phys. Rev. A., 54:1098,1996.

[CSG+05] J.H. Cole, S.G. Schirmer, A.D. Greentree, C.J.Wellard, D.K.L. Oi, and L.C.L. Hollenberg. Identifyingan experimental two-state Hamiltonian to arbitrary accu-racy. Phys. Rev. A., 71:062312, 2005.

[DA07] D.P. DiVincenzo and P. Aliferis. Effective Fault-Tolerant Quantum Computation with slow measurement.Phys. Rev. Lett., 98:020501, 2007.

[DFS+09] S.J. Devitt, A.G. Fowler, A.M. Stephens,A.D. Greentree, L.C.L. Hollenberg, W.J. Munro, andK. Nemoto. Architectural design for a topological clus-ter state quantum computer. New. J. Phys., 11:083032,2009.

[DG97] L.-M. Duan and G.-C. Guo. Preserving Coherence inQuantum Computation by Pairing quantum Bits. Phys.Rev. Lett., 79:1953, 1997.

[DG98a] L.-M. Duan and G.-C. Guo. Prevention of dissipa-tion with two particles. Phys. Rev. A., 57:2399, 1998.

[DG98b] L.-M. Duan and G.-C. Guo. Reducing decoherencein quantum computer-memory with all quantum bits cou-pling to the same environment. Phys. Rev. A., 57:737,1998.

[DKLP02] E. Dennis, A. Kitaev, A. Landahl, and J. Preskill.Topological Quantum Memory. J. Math. Phys., 43:4452,2002.

[DMN08] S.J. Devitt, W.J. Munro, and K. Nemoto. High Per-formance Quantum Computing. arxiv:0810.2444, 2008.

[DN06] C.M. Dawson and M.A. Nielsen. The Solovay-KitaevAlgorithm. Quant. Inf. Comp., 6:81, 2006.

[DS96] D.P. DiVincenzo and P.W. Shor. Fault-Tolerant errorcorrection with efficient quantum codes. Phys. Rev. Lett.,77:3260, 1996.

[DS00] M.H. Devoret and R.J. Schoelkopf. Amplifying Quan-tum Signals with the Single-Electron Transistor. Nature(London), 406:1039, 2000.

[DSO+07] S.J. Devitt, S.G. Schirmer, D.K.L. Oi, J.H. Cole,and L.C.L. Hollenberg. Subspace Confinement: How goodis your Qubit? New. J. Phys., 9:384, 2007.

[DWM03] S. Daffer, K. Wodkiewicz, and J.K. McIver. Quan-tum Markov Channels for Qubits. Phys. Rev. A.,67:062312, 2003.

[EJ96] A. Ekert and R. Jozsa. Quantum Computation andShor’s Factoring Algorithm. Rev. Mod. Phys., 68:733,1996.

[EK09] B. Eastin and E. Knill. Restrictions on Transver-sal Encoded Quantum Gate Sets. Phys. Rev. Lett.,102:110502, 2009.

[FG09] A.G. Fowler and K. Goyal. Topological cluster statequantum computing. Quant. Inf. Comp., 9:721, 2009.

[FLP04] P. Facchi, D.A. Lidar, and S. Pascazio. Unification ofdynamical decoupling and the quantum Zeno effect. Phys.Rev. A., 69:032314, 2004.

[Fow05] A.G. Fowler. PhD Thesis (Melbourne). quant-ph/0506126, 2005.

[FSG09] A.G. Fowler, A.M. Stephens, and P. Groszkowski.High threshold universal quantum computation on thesurface code. Phys. Rev. A., 80:052312, 2009.

[G83] P. Gacs. Reliable computation with cellular automata.Proc. ACM Symp. Th. Comput., 15:32, 1983.

[Gar91] C.W. Gardiner. Quantum Noise, volume 56 ofSpringer Series in Synergetics. Springer -Verlag, Berlin; New York, 1991.

[GBP97] M. Grassl, Th. Beth, and T. Pellizzari. Codes forthe quantum erasure channel. Phys. Rev. A., 56:33, 1997.

[GC99] D. Gottesman and I.L. Chuang. Demonstrating theviability of Universal Quantum Computation using tele-portation and single qubit operations. Nature (London),402:390, 1999.

[GHSZ90] D.M. Greenberger, M.A. Horne, A. Shimony, andA. Zeilinger. Bell’s theorem without inequalities. Am. J.Physics, 58:1131, 1990.

[GHZ89] D.M. Greenberger, M.A. Horne, and A. Zeilinger.Bell’s theorem, Quantum, and Conceptions of the Uni-verse. Kluwer Academic, Dordrecht, 1989.

[Got96] D. Gottesman. A Class of Quantum Error-CorrectingCodes Saturating the Quantum Hamming Bound. Phys.Rev. A., 54:1862, 1996.

[Got97] D. Gottesman. PhD Thesis (Caltech). quant-ph/9705052, 1997.

[Got98] D. Gottesman. A theory of Fault-Tolerant quantumcomputation. Phys. Rev. A., 57:127, 1998.

[Got00] D. Gottesman. Fault-Tolerant Quantum Computa-tion with Local Gates. J. Mod. Opt., 47:333, 2000.

[Got02] D. Gottesman. An Introduction to Quantum ErrorCorrection. Quantum Computation: A Grand Mathemat-ical Challenge for the Twenty-First Century and the Mil-lennium, S. J. Lomonaco, Jr. ed, pp. 221-235 (AmericanMathematical Society, Providence, Rhode Island), quant-ph/0004072, 2002.

[Got09] D. Gottesman. An Introduction to Quantum Er-ror Correction and Fault-Tolerant Quantum Computa-tion. arXiv:0904.2557, 2009.

[HMCS00] J.J. Hope, G.M. Moy, M.J. Collett, and C.M. Sav-age. Steady-State quantum statistics of a non-Markovianatom laser. Phys. Rev. A., 61:023603, 2000.

[IFI+02] L.B. Ioffe, M.V. Feigel’man, A. Ioselevich,D. Ivanov, M. Troyer, and G. Blatter. Topologi-cally protected quantum bits from Josephson junctionarrays. Nature (London), 415:503, 2002.

[IHY85] N. Imoto, H.A. Haus, and Y. Yamamoto. Quantumnondemolition measurement of the photon number via theoptical Kerr effect. Phys. Rev. A., 32:2287, 1985.

[JFS06] S.P. Jordan, E. Farhi, and P.W. Shor. Error correct-ing codes for adiabatic quantum computation. Phys. Rev.A., 74:052322, 2006.

[Jon09] J. A. Jones. Composite pulses in NMR quantum com-putation. J. Ind. Inst. Sci., 89:303, 2009.

[KC08] A. Kay and R. Colbeck. Quantum Self-CorrectingStabilizer Codes. arxiv:0810.3557, 2008.

[Kit97] A.Y. Kitaev. Quantum Computations: algorithmsand error correction. Russ. Math. Serv., 52:1191, 1997.

[KL97] E. Knill and R. Laflamme. Theory of quantum error-correcting codes. Phys. Lett. A, 55:900, 1997.

[KL00] E. Knill and R. Laflamme. A Theory of QuantumError-Correcting Codes. Phys. Rev. Lett., 84:2525, 2000.

[KL05] K. Khodjasteh and D.A. Lidar. Fault-Tolerant Quan-tum Dynamical Decoupling. Phys. Rev. Lett., 95:180501,2005.

[KLA+02] E. Knill, R. Laflamme, A. Ashikhmin, H. Barnum,L. Viola, and W.H. Zurek. Introduction To Quantum Er-ror Correction. Los Alamos Science, 27:188, 2002.

[KLM01] E. Knill, R. Laflamme, and G.J. Milburn. A Schemefor Efficient Quantum Computation with linear optics.

37

Nature (London), 409:46, 2001.[KLP05] D. Kribs, R. Laflamme, and D. Poulin. Unified

and Generalized Approach to Quantum Error Correction.Phys. Rev. Lett., 94:180501, 2005.

[KLPL06] D. Kribs, R. Laflamme, D. Poulin, and M. Lesosky.Operator Quantum Error Correction. Quant. Inf. Comp.,6:383, 2006.

[KLV00] E. Knill, R. Laflamme, and L. Viola. Theory ofQuantum Error Correction for General Noise. Phys. Rev.Lett., 84:2525, 2000.

[KLZ96] E. Knill, R. Laflamme, and W.H. Zurek. Accuracythreshold for Quantum Computation. quant-ph/9610011,1996.

[KLZ98] E. Knill, R. Laflamme, and W.H. Zurek. ResilientQuantum Computation. Science, 279:342, 1998.

[Kni96] E. Knill. Non-binary Unitary Error Bases andQuantum Codes. LANL report LAUR-96-2717, quant-ph/9608048, 1996.

[Kni05] E. Knill. Quantum computing with realistically noisydevices. Nature (London), 434:39, 2005.

[Kol09] V. Kolmogorov. Blossom V: A new implementation ofa minimum cost perfect matching algorithm. Math. Prog.Comp., 1:43, 2009.

[LCW98] D.A. Lidar, I.L. Chuang, and K.B. Whaley.Decoherence-Free Subspaces for Quantum Computation.Phys. Rev. Lett., 81:2594, 1998.

[Lev86] M.H. Levitt. Composite Pulses. Prog. NMR Spec-troscopy, 18:61, 1986.

[LF79] M.H. Levitt and R. Freeman. NMR Population Inver-sion Using a Composite Pulse. J. Magn. Reson., 33(473),1979.

[LMPZ96] R. Laflamme, C. Miquel, J.P. Paz, and W.H.Zurek. Perfect Quantum Error Correcting Code. Phys.Rev. Lett., 77:198, 1996.

[LS98] S. Lloyd and J. E. Slotine. Analog Quantum ErrorCorrection. Phys. Rev. Lett., 80:4088, 1998.

[LW03] D.A. Lidar and K.B. Whaley. Decoherence-FreeSubspaces and Subsystems. Irreverible Quantum Dy-namics, F. Benatti and R. Floreanini, eds, pp.83-120(Springer Lecture notes in Physics vol 622, Berlin), quant-ph/0301032, 2003.

[MCM+05] J.M. Martinis, K.B. Cooper, R. McDermott,M. Steffen, M. Ansmann, K.D. Osborn, K. Cicak, S. Oh,D.P. Pappas, R.W. Simmonds, and C.C. Yu. Decoherencein Josephson Qubits for Dielectric Loss. Phys. Rev. Lett.,95:210503, 2005.

[MCT+04] T. Metodiev, A. Cross, D. Thaker, K. Brown,D. Copsey, F.T. Chong, and I.L. Chuang. Prelimi-nary Results on Simulating a Scalable Fault-TolerantIon Trap system for quantum computation. In 3rdWorkshop on Non-Silicon Computing (NSC-3), on-line:www.csif.cs.ucdavis.edu/ metodiev/papers/NSC3-setso.pdf, 2004.

[MLFY10] R. Van Meter, T.D. Ladd, A.G. Fowler, and Y. Ya-mamoto. Distributed Quantum Computation Architec-ture Using Semiconductor Nanophotonics. Int. J. Quant.Inf., 8:295, 2010.

[MNBS05] W.J. Munro, K. Nemoto, R.G. Beausoleil, andT.P. Spiller. High-effciency quantum-nondemolitionsingle-photon-number-resolving detector. Phys. Rev. A.,71:033819, 2005.

[MW84] G.J. Milburn and D.F. Walls. State reductionin quantum-counting quantum nondemolition measure-ments. Phys. Rev. A., 30:56, 1984.

[NC00] M.A. Nielsen and I.L. Chuang. Quantum Computa-tion and Information. Cambridge University Press, secondedition, 2000.

[Neu55] J. Von Neumann. Probabilistic logics and the syn-thesis of reliable organisms from unreliable components.Automata Studies, 43, 1955.

[NSS+08] C. Nayak, S.H. Simon, A. Stern, M. Freedman, andS. Das Sarma. Non-Abelian anyons and topological quan-tum computation. Rev. Mod. Phys., 80:1083, 2008.

[PCZ97] J.F. Poyatos, J.I. Cirac, and P. Zoller. CompleteCharacterization of a quantum process; the two-bit quan-tum gate. Phys. Rev. Lett., 78:390, 1997.

[POW+04] G.J. Pryde, J.L. O’Brien, A.G. White, S.D.Bartlett, and T.C. Ralph. Measuring a photonic qubitwithout destroying it. Phys. Rev. Lett., 92:190402, 2004.

[Pre98] J. Preskill. Introduction To Quantum Computa-tion. Introduction to Quantum Computation, H.-K. Lo,S. Popescu, T. Spiller eds, pp. 213-270, (World Scientific,Singapore), quant-ph/9712048, 1998.

[PSE96] G. Massimo Palma, K-A. Suominen, and A.K. Ekert.Quantum Computers and Dissipation. Proc. Royal Societyof London A., 452:567–584, 1996.

[PVK97] M.B. Plenio, V. Vedral, and P.L. Knight. QuantumError Correction in the Presence of Spontaneous Emission.Phys. Rev. A., 55:67, 1997.

[RB01] R. Raussendorf and H.-J. Briegel. A One way Quan-tum Computer. Phys. Rev. Lett., 86:5188, 2001.

[RH07] R. Raussendorf and J. Harrington. Fault-tolerantquantum computation with high threshold in two dimen-sions. Phys. Rev. Lett., 98:190504, 2007.

[RHG05] T.C. Ralph, A.J.F. Hayes, and A. Gilchrist. LossTolerant Optical Qubits. Phys. Rev. Lett., 95:100501,2005.

[RHG07] R. Raussendorf, J. Harrington, and K. Goyal. Topo-logical fault-tolerance in cluster state quantum computa-tion. New J. Phys., 9:199, 2007.

[SBD09] T.M. Stace, S.D. Barrett, and A.C. Doherty.Thresholds for topological codes in the presence of loss.Phys. Rev. Lett., 102:200501, 2009.

[SBF+06] T. Szkopek, P.O. Boykin, H. Fan, V.P. Roychowd-hury, E. Yablonovitch, G. Simms, M. Gyure, and B. Fong.Threshold Error Penalty for Fault-Tolerant Computationwith Nearest Neighbour Communication. IEEE Trans.Nano., 5:42, 2006.

[SDT07] K.M. Svore, D.P. DiVincenzo, and B.M. Terhal.Noise Threshold for a Fault-Tolerant Two-DimensionalLattice Architecture. Quant. Inf. Comp., 7:297, 2007.

[SEDH08] A. Stephens, Z. W. E. Evans, S. J. Devitt, andL.C.L. Hollenberg. Subsystem Code Conversion. Phys.Rev. A., 77:062335, 2008.

[SFH08] A. Stephens, A.G. Fowler, and L.C.L. Hollenberg.Universal Fault-Tolerant Computation on bilinear nearestneighbor arrays. Quant. Inf. Comp., 8:330, 2008.

[Sho95] P.W. Shor. Scheme for reducing decoherence in quan-tum computer memory. Phys. Rev. A., 52:R2493, 1995.

[Sho96] P.W. Shor. Fault-Tolerant quantum computation.Proc. 37th IEEE Symp. on Foundations of Computer Sci-ence., pages 56–65, 1996.

[Sho97] P.W. Shor. Polynomial-Time algorithms for PrimeFactorization and Discrete Logarithms on a QuantumComputer. SIAM Journal of Sci. Statist. Comput.,26:1484, 1997.

[SI05] A.M. Steane and B. Ibinson. Fault-Tolerant LogicalGate Networks for Calderbank-Shor-Steane codes. Phys.

38

Rev. A., 72:052335, 2005.[SJ09] R. Stock and D.F.V. James. A Scalable, high-speed

measurement based quantum computer using trappedions. Phys. Rev. Lett., 102:170501, 2009.

[ST00] J. Steinbach and J. Twamley. Motional Quantum Er-ror Correction. J. Mod. Opt., 47:453, 2000.

[Ste96a] A.M. Steane. Error Correcting Codes in QuantumTheory. Phys. Rev. Lett., 77:793, 1996.

[Ste96b] A.M. Steane. Multiple particle interference andquantum error correction. Proc. Royal Society of LondonA., 452:2551, 1996.

[Ste96c] A.M. Steane. Simple quantum error-correctingcodes. Phys. Rev. A., 54:4741, 1996.

[Ste97a] A.M. Steane. Active Stabilization, Quantum Com-putation and Quantum State Synthesis. Phys. Rev. Lett.,78:2252, 1997.

[Ste97b] A.M. Steane. The Ion Trap Quantum InformationProcessor. Appl. Phys. B, 64:623, 1997.

[Ste01] A.M. Steane. Quantum Computing and Error Cor-rection. Decoherence and its implications in quantumcomputation and information transfer, Gonis and Turchi,eds, pp.284-298 (IOS Press, Amsterdam, 2001), quant-ph/0304016, 2001.

[Ste02] A.M. Steane. Fast Fault-Tolerant filtering of quantumcodewords. quant-ph/0202036, 2002.

[Tof81] T. Toffoli. Bicontinuous extension of reversible com-binatorial functions. Math. Syst. Theory, 14:13–23, 1981.

[Uhr07] G.S. Uhrig. Keeping a Quantum Bit Alive by Op-timized -Pulse Sequences. Phys. Rev. Lett., 98:100504,2007.

[Unr95] W.G. Unruh. Maintaining Coherence in QuantumComputers. Phys. Rev. A., 51:992, 1995.

[VK03] L. Viola and E. Knill. Robust Dynamical Decouplingof Quantum Systems with Bounded Controls. Phys. Rev.Lett., 90:037901, 2003.

[VK05] L. Viola and E. Knill. Random Decoupling Schemesfor Quantum Dynamical Control and Error Suppression.Phys. Rev. Lett., 94:060502, 2005.

[VKL99] L. Viola, E. Knill, and S. Lloyd. Dynamical De-coupling of Open Quantum Systems. Phys. Rev. Lett.,82:2417, 1999.

[VL98] L. Viola and S. Lloyd. Dynamical suppression of de-coherence in two-state quantum systems. Phys. Rev. A.,58:2733, 1998.

[vL08] P. van Loock. A Note on Quantum Error Correctionwith Continuous Variables. arxiv:0811.3616, 2008.

[VT99] D. Vitali and P. Tombesi. Using parity kicks for de-coherence control. Phys. Rev. A., 59:4178, 1999.

[VWW05] J. Vala, K.B. Whaley, and D.S. Weiss. Quantumerror correction of a qubit loss in an addressable atomicsystem. Phys. Rev. A., 72:052318, 2005.

[WBL02] L.-A. Wu, M.S. Byrd, and D.A. Lidar. EfficientUniversal Leakage Elimination for Physical and EncodedQubits. Phys. Rev. Lett., 89:127901, 2002.

[WFSH10] D.S. Wang, A.G. Fowler, A.M. Stephens, andL.C.L. Hollenberg. Threshold Error rates for the toricand surface codes. Quant. Inf. Comp., 10:456, 2010.

[WZ82] W.K. Wooters and W.H. Zurek. A Single QuantumCannot be Cloned. Nature (London), 299:802, 1982.

[YNM06] F. Yamaguchi, K. Nemoto, and W.J. Munro. Quan-tum error correction via robust probe modes. Phys. Rev.A., 73:060302(R), 2006.

[Zan99] P. Zanardi. Symmetrizing evolutions. Phys. Lett. A,258:77, 1999.

[ZR97a] P. Zanardi and M. Rasetti. Error Avoiding QuantumCodes. Mod. Phys. Lett. B., 11:1085, 1997.

[ZR97b] P. Zanardi and M. Rasetti. Noisless Quantum Codes.Phys. Rev. Lett., 79:3306, 1997.