Adiabatic topological quantum computing

Chris Cesare,1, 2, ∗ Andrew J. Landahl,3, 1, 2, † Dave Bacon,4, 5, ‡ Steven T. Flammia,6, § and Alice Neels4, ¶

1Center for Quantum Information and Control, University of New Mexico, Albuquerque, NM, 87131, USA2Department of Physics and Astronomy, University of New Mexico, Albuquerque, NM, 87131, USA

3Advanced Device Technologies, Sandia National Laboratories, Albuquerque, NM, 87185, USA4Department of Computer Science and Engineering,University of Washington, Seattle, WA, 98195, USA

5Department of Physics, University of Washington, Seattle, WA 98195, USA6Centre for Engineered Quantum Systems, School of Physics,

The University of Sydney, Sydney, NSW 2006, Australia

Topological quantum computing promises error-resistant quantum computation without activeerror correction. However, there is a worry that during the process of executing quantum gatesby braiding anyons around each other, extra anyonic excitations will be created that will disorderthe encoded quantum information. Here we explore this question in detail by studying adiabaticcode deformations on Hamiltonians based on topological codes, notably Kitaev’s surface codes andthe more recently discovered color codes. We develop protocols that enable universal quantumcomputing by adiabatic evolution in a way that keeps the energy gap of the system constant withrespect to the computation size and introduces only simple local Hamiltonian interactions. Thisallows one to perform holonomic quantum computing with these topological quantum computingsystems. The tools we develop allow one to go beyond numerical simulations and understand theseprocesses analytically.

PACS numbers: 03.67.Lx, 03.67.-a, 03.67.Pp, 03.67.Ac, 03.65.Vf

I. INTRODUCTION

There are many approaches to constructing a quantumcomputer. In addition to the numerous different physi-cal substrates available, there are a plethora of differ-ent underlying computational architectures from whichto choose. Two major classes of architectures can be dis-tinguished: those requiring a substantial external activecontrol system to suppress errors [1–3], and those whoseunderlying physical construction eliminates much, if notall, of the need for such a control system [4, 5]. Thefirst class of architectures strives to minimize the controlresources needed to quantum compute fault-tolerantly.The second class of architectures strives to minimize thecomplexity of systems that enable fault-tolerant quan-tum computation intrinsically. Here we focus on the lat-ter class of architectures and address the question: “Howdoes one quantum compute on a system protected fromdecoherence by a static (i.e., time-independent) Hamil-tonian?” We present a solution that adiabatically inter-polates between static Hamiltonians, each of which pro-tects the quantum information stored in its ground space.Since each of these ground spaces can be described asa quantum error-correcting codespace, we call this pro-

∗chris.cesare@gmail.com†alandahl@sandia.gov‡dabacon@gmail.com; current affiliation: Google, Inc., 651 N. 34thSt. Seattle, WA, 98103, USA§sflammia@physics.usyd.edu.au¶aliceen@gmail.com; current affiliation: Splunk, Inc., 250 BrannanSt., 1st Floor, San Francisco, CA 94107, USA

cess adiabatic code deformation [6, 7]. This procedureamounts to a simulation of the measurement-based pro-cess of code deformation employed in the first class ofarchitectures [8–14]. We further show that this proce-dure preserves the energy gap of the system throughoutthe evolution.

While previous work has made reference to adiabaticevolutions as a method for performing topological quan-tum computation [15], our work can be seen as makingthe assumptions of adiabatic evolution explicit for certainmodels of topological quantum computers. In contrast,for example, to topological quantum computing in frac-tional quantum Hall systems where even the ground stateof the system is subject to debate, our models are exactlysolvable and simple. Similar work has been performed forKitaev’s honeycomb model by Lahtinen and Pachos [16],who examined the adiabatic transport of vortices in Ki-taev’s honeycomb lattice model numerically. Here, weare able to investigate these issues analytically.

Our results marry three different lines of research,which we now describe. The first is the idea origi-nated by Kitaev [4] that quantum information can beprotected from decoherence by encoding it into the de-generate ground space of a many-body quantum system.In particular, Kitaev suggested a family of systems suchthat each system has a ground space equivalent to a quan-tum error-correcting codespace. Moreover, each of theseground spaces is separated from its first-excited spaceby an energy gap—a gap that does not shrink with thesystem size (i.e., the gap is “constant”).

In Kitaev’s original construction, the quantum error-correcting code also possesses a topological property thatmakes the distance of the code grow with the number of

arX

iv:1

406.

2690

v1 [

quan

t-ph

] 1

0 Ju

n 20

14

2

qubits in the system. This implies that any local per-turbing interaction will only split the energy of a degen-erate ground state by an exponentially small amount inthe size of the system [17]. Information encoded intothe ground space should therefore remain well-protectedfrom the detrimental effects of decoherence. Further, ifone immerses the system in a bath with a temperaturelower than that of the energy gap in the system, thenone should expect a suppression of thermal excitationsout of the ground space. The decay rate of the quan-tum information encoded into the ground space is notset by a length scale in the system, but instead the life-time scales as exp(cβ∆) where β is the inverse temper-ature, ∆ is the energy gap of the Hamiltonian, and c isa constant [18]. Crucially, this implies that the lifetimeof the information is exponentially lengthened as a func-tion of the inverse temperature. While one does not ob-tain, using Kitaev’s original idea, a method for protectingquantum information with a lifetime that grows with thesize of the system—a hallmark of “self-correcting” quan-tum memories [8, 19]—for a suitably low temperature,the information lifetime will be long enough for all prac-tical purposes. Thus, via the use of a static many-bodyHamiltonian, Kitaev proposed that quantum informationcould be protected without resorting to active quantumerror-correcting algorithms.

Following Kitaev’s introduction of this idea, numer-ous authors put forward similar approaches. Many ofthese ideas stayed within the realm of topological protec-tion [15, 20–24], but others explored energetic protectionwithout reference to topological ideas [25–28]. Here wewill focus on the topological models, but many of ourresults apply in the more general setting.

Kitaev noted in his original proposal that the excitedstates of his Hamiltonian act as particles with exoticstatistics. In particular, he showed that the excitationswere quasiparticles called anyons [29]—particles that ex-ist in two spatial dimensions that exhibit statistics dif-ferent from fermions and bosons and which interact bybraiding around one another in spacetime—an interac-tion that only depends on the topology of the anyonworldlines. These excitations not only describe errorsin the codespace but can also be thought of as quan-tum information carriers in their own right. Indeed forsome many-body Hamiltonians, it is possible to have non-abelian anyons (anyons whose braidings do not commute)that perform universal quantum computation in the la-bel space of the anyons. This is known as topologicalquantum computing [4, 30–32], the principal model ofquantum computing we will consider here.

In a topological quantum computation, one createsanyons from the vacuum, braids them around one an-other in spacetime, fuses them together, then recordstheir label types. Although the topological nature ofthe anyonic interaction provides a degree of control ro-bustness, it is not immediately clear why the processes ofanyon creation and fusion could not create new unwantedanyons. Such anyons could in turn wander and disrupt

the desired braid. The initialization process in particularis quite subtle [33]. Moreover, there will likely be a back-ground of thermal anyons and anyons arising from mate-rial defects which could also disorder the quantum com-putation. On top of all of this, even if a spacetime braidis topologically correct, the mere act of moving anyonsaround at any nonzero speed has the potential to gener-ate new excitations because the adiabatic approximationis not exact. Measurement-based topological quantumcomputation [34, 35] has the potential to overcome thislast problem, but the other problems remain. In sum-mary, the great merit of topological quantum computa-tion is that the “only” thing that can corrupt it is uncon-trolled anyons—the problem is that there are many waysthat uncontrolled anyons can arise. Even something asseemingly innocuous as a lack of complete knowledge ofthe system’s Hamiltonian could do this because it couldlead to anyons being trapped or leaking out of the systemunbeknownst to the computer operator [15]. We do notclaim to address every possible adversarial scenario fortopological quantum computation here; our focus is onconstructing an architecture that limits the chances foruncontrolled anyons to appear.

The second line of research relevant to our proposal isthe recent use of code deformations to perform quantumcomputation on topological quantum error-correctingcodes [8–10, 12, 32]. In this approach, one works directlywith the quantum-error correcting code used in topolog-ical quantum computing without introducing a Hamil-tonian to provide energetic protection of the quantuminformation. Instead, one focuses on active error correc-tion, but performed with the topological quantum codes.Consideration of such codes for quantum error correc-tion was first examined in detail by Dennis et al. [8]. Inthis approach, qubits are arranged on a two-dimensionalsurface with a boundary, resulting in a single encodedqubit for each such surface. In order to build a quan-tum computer with more than one qubit, such surfacesare stacked on top of each other so that transversal gatescan be achieved between the neighboring surfaces. Sincethe original analysis, modifications [10, 36] of this ar-chitecture have been introduced that have considerableadvantages over the three-dimensional stacking of Den-nis et al. In these models, one takes a surface code and“punctures” it by removing the quantum check opera-tors (stabilizer generators) from a region, creating a de-fect [37]. For each defect, one obtains an encoded qubitwith a code distance that is the minimum of the perime-ter of the defect and the distance from the defect to thenearest appropriate boundary (which may lie on anotherdefect). One can show that, via a sequence of adaptivemeasurements, one can deform the boundary of the de-fect, and, by using suitable deformations, braid defects insuch a way that logical operations are performed betweenthe logical qubits associated with the defects.

The third line of research relevant to our proposal is therecent discovery of methods to perform holonomic [38]and open-loop holonomic [39] universal quantum compu-

3

tation in a stabilizer code setting [6, 7, 40]. In holonomicquantum computing, adiabatic changes of a Hamiltonianwith degenerate energy levels around a loop in parame-ter space induce unitary gates on each energy eigenspace.The enacted gate depends on geometric properties of theHamiltonian path and not on the exact timing used totraverse it (to within the limits of the adiabatic approx-imation), thus offering a method to avoid some timingerrors. Universal quantum computation using holonomicmethods was originally studied in Ref. [38]. Recently,Oreshkov et al. demonstrated a novel manner for achiev-ing universality within the context of fault-tolerant quan-tum computing [6]. In particular, this result showed howto perform gates on information encoded into a quan-tum stabilizer code. Building along these lines, twoof the present authors (DB and STF) have shown howto achieve similar constructions within the context ofopen-loop holonomic quantum computation [7, 41]. Inthis setting, instead of using cyclic evolutions, one canquantum compute using non-cyclic evolutions. A con-sequence of this is a scheme known as adiabatic gateteleportation where one mimics gate teleportation viaa very simple interpolation between two-qubit interac-tions [7]. Another consequence is that it is possible toperform measurement-based quantum computing [42] us-ing only adiabatic deformations of a Hamiltonian [41].Further, and more suggestive for this work, it is possibleto perform holonomic quantum computation on symme-try protected spin chains [43]. Holonomic quantum com-putation, whether performed cyclically or non-cyclically,should be distinguished from (universal) adiabatic quan-tum computation, in which the ground state is alwaysnondegenerate throughout the non-cyclic adiabatic evo-lution [44–48].

In this work, we combine many of the above insightsinto a new method for computing on information encodedinto the energy levels of a Hamiltonian. We consider asituation where, as in the first line of research, quan-tum information is encoded into the ground state of atopologically ordered many-body system. Rather thanstoring information in the label space of anyons them-selves, we consider information stored in defects, whichact somewhat like anyons, as in the second line of re-search. We then examine explicit adiabatic interpola-tions between Hamiltonians that simulate code deforma-tion, as in the third line of research. This is all donewhile keeping the energy gap in the system constant, anecessary requirement to use these techniques to main-tain the topological protection offered by these systems.Further, we demonstrate how to prepare quantum in-formation into fiducial states using adiabatic evolutions.Some of these state-preparation procedures are robust toerror, but some (e.g., the preparation of certain “magicstates” [49]) are not robust and thus require distillationprotocols. Finally, we discuss how one can use code de-formations to facilitate measurements of certain logicaloperators. We discuss all of these procedures first withinthe context of Kitaev’s surface codes with defects, and

then we discuss how these results can be extended to thetopological color codes [50].

The systems and protocols we use are not strictly fault-tolerant. Without active error correction, the lifetime ofthe codes studied are a constant independent of the sys-tem size [18]. As mentioned above, here we rely on a cou-pling to a cold (with respect to the gap) thermal bath,which suppresses the creation of errors exponentially inthe size of the gap. We retain robustness to things likecontrol errors by virtue of the holonomic nature of thelogical operations we implement, and robustness to corre-lated fluctuations induced by the environment by keepingdefects well-separated during braiding. Once the envi-ronment creates an excitation, it is free to wander andcorrupt the computation. We prevent the environmentfrom doing this by ensuring that it is cold, and we pre-vent ourselves from introducing excitations accidentallyby carefully designing our procedures.

II. SURFACE CODES WITH DEFECTS

We begin by working with a simple class of surfacecodes with defects to establish the main ideas behindour procedures. In Section VII we extend these ideas tothe topological color codes. We assume that the readeris familiar with the theory of stabilizer codes [51], toriccodes [4], and surface codes [37], which are specializationsof toric codes to bounded planar surfaces. However, wereview these subjects to set our notation.

Z

Z

Z

Z p

X

X

X

X s

FIG. 1: Stabilizer generators (checks) for the surface code.An example of a plaquette check Sp and a vertex check Sv.

Let L be a two-dimensional square lattice that is l

4

edges (or links) wide and l edges tall, with the leftmostl vertical edges and bottommost l horizontal edges re-moved. (Other lattices are possible; we make this restric-tion only to be concrete.) We call the sides of the latticewith the edges removed the rough or X-type boundariesand the other sides the smooth or Z-type boundaries; seeFig. 2. A qubit is associated with each edge of the latticeso that there are 2l2 qubits in total. For each plaquette(or face), p, of the lattice, define the plaquette operatorSp =

⊗e∈∂p Ze where ∂p denotes the edges bounding the

plaquette and Ze is the Pauli Z operator acting on thequbit at edge e. In other words Sp acts as the tensorproduct of Z operators on the qubits touching the pla-quette p and acts trivially everywhere else in the lattice(see Fig. 1). Similarly, for each vertex (or site) in thelattice, define a vertex operator Sv =

⊗e∈δvXe, where

δv denotes the edges incident at vertex v and Xe is thePauli X operator acting on the qubit at edge e. In otherwords, Sv acts as a tensor product of Pauli X operatorson all the edges surrounding a vertex and acts triviallyon all the other qubits in the lattice, as shown in Fig. 1.

It is important to note that the rough and smoothboundaries still have plaquette and vertex operators de-fined on them; these operators simply act nontrivially onfewer qubits than the operators in the bulk of the lattice.Since the lattice L has l2 plaquettes and l2 vertices, thereare also l2 plaquette operators and l2 vertex operators.These operators are all independent in the sense that nostrict subset can generate the rest, and, moreover, theyall commute since they are incident on each other an evennumber of times.

The collection of all the Sp and Sv operators comprisesthe set of stabilizer generators for a quantum surfacecode, the codespace being defined by the simultaneous+1 eigenspace of all the stabilizer generators. This setgenerates the stabilizer group for the code, which is sim-ply the set of all the products of generators. The abovedescription actually specifies a single state rather than acodespace since it has 2l2 checks on 2l2 qubits. This is aconsequence of the particular way in which we chose theboundary of the lattice, which disallows the existence ofany additional operators that commute with all of thegenerators but which are not elements of the stabilizergroup. Encoding quantum information in the lattice re-quires the constructions described next.

Consider a closed simple curve c on L that does notcross itself and that does not touch the boundary of L.Call the interior of this loop, excluding c itself, Ic. Con-sider “removing” all of the qubits in Ic. Here by “remov-ing” we do not mean physically removing the qubits, butrather that we consider a new code in which the stabi-lizer generators exterior to the region Ic are consistentwith the description above, while the region Ic has a dif-ferent set of stabilizer generators (not necessarily of theplaquette and vertex type). We call this process punc-turing (not to be confused with the notion of puncturingassociated with classical coding theory [52]), and the re-sulting region of removed qubits is called a defect. Given

X

Z

FIG. 2: A smooth (Z-type) defect. A logical Z operator isdefined by a closed loop of Zs on the lattice that surroundsthe defect and a logical X operator is defined by a connectedpath of Xs on the dual lattice from the defect to a smooth(Z-type) boundary. Here we depict the removed region byremoving that part of the lattice; this simply indicates thatthe code of the system factors into a code in the drawn regionand a code inside of the defect.

such a defect, we can study the properties of the newcode induced on the exterior of Ic. Careful counting ofthe stabilizer generators and qubits in this new code re-veals that the puncturing procedure has created a logi-cal qubit [37]. The logical operators for the new logicalqubit can be chosen as follows: an encoded Z is a closedloop of Z operators on the lattice L that encircles thedefect and an encoded X is a connected path of X op-erators on the dual lattice L∗ that starts on the smooth(Z-type) boundary of the defect and ends on a smooth(Z-type) boundary of the lattice L other than the loopc (see Fig. 2). The distance of this code is the minimumof the length of curves on L bounding the defect andthe length of paths connecting the defect to a smooth(Z-type) boundary of L. We note that the curve c itselfis the minimum-weight choice for the encircling logicalZ operator. Similarly, instead of starting with a sim-ple closed curve on the lattice, we can consider a simpleclosed curve on the dual lattice and remove the interiorof this curve. To be consistent with the definition givenfor the former kind of defect, we must define the encodedX to be a closed loop c∗ of X operators on the dual lat-tice L∗ that encircles the defect and the encoded Z tobe a connected path of Z operators on the lattice L thatstarts on the rough (X-type) boundary of the defect andends on a rough (X-type) boundary of the lattice L otherthan the loop c∗ (see Fig. 3).

Puncturing the surface code creates a single encoded

5

X

Z

FIG. 3: A rough (X-type) defect. A logical X operator is de-fined by a closed loop of Xs on the dual lattice that surroundsthe defect and a logical Z operator is defined by a connectedpath of Zs on the lattice from the defect to a rough (X-type)boundary.

qubit. By puncturing multiple times we can create acode with more than one encoded qubit, one for each ad-ditional puncture. The boundary curves of these defectscan be on the lattice, in which case we call the defectsmooth (Z-type), or on the dual lattice, in which casewe call the defect rough (X-type). The distance of sucha code is the minimum of the distance between defects,the distance between a defect and the boundary of thelattice, and the circumference of a defect.

Surface codes with defects were first explored withinthe framework of active quantum error correction. Herewe consider an alternative situation in which we con-struct a Hamiltonian with a ground space that is degen-erate and identical to the codespace of a quantum errorcorrecting code. The construction of such a Hamiltonianis easy from a theoretical point of view; it is simply thenegative sum of the stabilizer generators, G,

H = −∆

2

∑

S∈GS. (1)

The constant in front is chosen so that all errors willhave an energy penalty of a least ∆ (errors adjacent to aboundary will have this penalty, while errors away fromboundaries will have a penalty of 2∆). Since the set ofgenerators is commutative, the eigenspaces of H can belabeled by their eigenvalues with respect to the operatorsS. Because the eigenvalues of all the S are±1, the groundstate of this Hamiltonian is equivalent to the codespaceof the quantum code generated by G: S|ψ〉 = |ψ〉 for allS ∈ G.

Hamiltonians like that in Eq. (1), which we call sta-bilizer Hamiltonians, have interesting properties for pro-tecting quantum information. The first property is thatoperators that act nontrivially on the codespace (the de-generate ground space) must be nonlocal, having a Pauli-weight at least as large as the code’s distance. This allowsthe system to retain its information even when perturbedby a local Hamiltonian [17, 53]. For toric codes, surfacecodes, color codes, and, more generally, codes formedfrom quantum double models [54], this is a partial in-dication of a topological order in the system. (A morerobust indicator would be a nontrivial topological entan-glement entropy [55–58].)

While a stabilizer Hamiltonian is robust to local per-turbations, if the system is immersed in a thermal bath,the lifetime of information encoded into the ground statedoes not necessarily scale with the size of the system(or the size of the defect for a surface code with de-fects). For example, for the toric code, the lifetime ofthis information is proportional to exp(2β∆) [18], whereβ = (kBT )−1 is the inverse temperature of the bath. Itis widely believed that all stabilizer Hamiltonians withlocal terms embedded in two spatial dimensions have asimilar lifetime [59]. The more challenging issue is how tocompute with them without increasing the rate at whichinformation is destroyed. As mentioned in Sec. I, if a sta-bilizer Hamiltonian describes a topologically ordered sys-tem possessing anyons with a sufficiently rich nonabelianstructure, then quantum computation can be carried outby creating, braiding, and fusing the anyons. However, itis not entirely clear that one can controllably create sin-gle excitations without also creating other uncontrolledexcitations that could then disorder the system, nor howone can move the anyons without causing other anyons tobe produced. This has led to the search for self-correctingquantum systems where the excitations are not point-likeparticles like anyons but structures that have boundarieswith dimension [8, 19, 59]. The energetic cost of an ex-citation in such a system is proportional to the size ofits boundary and thus would be robust to errors duringcreation and movement processes—such a system wouldenergetically favor shrinking the boundaries of the errorsto zero, causing them to vanish. In particular, it has beenargued that such systems would have a lifetime propor-tional to their size, indicating that the system and theenvironment to which it is coupled participate in a formof “self-correction” in which the environment that createsthe errors can also fix the errors; at a low enough temper-ature, the rate of the latter process dominates the rate ofthe former. In this paper, we do not directly address thequestion of self-correction; instead we attempt to betterunderstand how computation can be done adiabaticallywithin existing models.

6

III. ADIABATIC CODE DEFORMATIONS

Before showing how to perform the adiabatic defor-mations and creation of fiducial states, we briefly reviewa scheme for performing adiabatic gate teleportation [7](AGT), as this gives an idea of how the protocols weintroduce below operate. AGT is a procedure for trans-ferring information in one qubit to information in anotherqubit (with a possible gate applied to this information)via the use of an adiabatic evolution and an ancillaryqubit. The following example is on a system composedof three qubits in which the first and third qubit areswapped (without a gate applied during the swapping).Initially the system evolves under a Hamiltonian givenby

Hi = −∆(I1X2X3 + I1Z2Z3), (2)

where Pi represents the operator P acting on the ithqubit and where we soon omit the identity operators I.A final Hamiltonian is defined as

Hf = −∆(X1X2I3 + Z1Z2I3). (3)

The AGT protocol begins with the information encodedin the first qubit and Hi turned on. Then, Hi is adiabat-ically turned off while simultaneously turning on Hf . Inother words, the evolution is described by

H(t) = f(t)Hi + g(t)Hf , (4)

where f(0) = 1, f(T ) = 0, g(0) = 0 and g(T ) = 1 and Tis the time taken to perform the evolution. If f(t) andg(t) are chosen to be slowly varying and the time T islong enough such that the evolution is adiabatic (meaninghere that the probability of exciting the system out of itsground space is made small), then the above evolutionwill take information in the first qubit and send it toinformation in the third qubit. For example, one maychoose f(t) = 1−g(t) and g(t) = t

T so that the evolutionis made adiabatic for sufficiently large T . A constanterror can be achieved for a fixed constant T .

To see that a constant energy gap is maintained duringthe above evolution and that the information is trans-ported from the first to third qubit, it is convenient touse the formalism of stabilizer codes to describe this evo-lution. Indeed, it is actually useful to define three codes.The first code, call it S1, is defined by the stabilizergenerators X2X3 and Z2Z3 and the logical Pauli oper-ators Z = Z1Z2Z3 and X = X1X2X3. A second code,call it S2, is defined by the stabilizer generators X1X2

and Z1Z2 and the logical Pauli operators Z = Z1Z2Z3

and X = X1X2X3. Suppose information is encodedinto the stabilizer code S1 so that it is in the +1 eigen-state of both X2X3 and Z2Z3. Notice then that becauseX1 = X(X2X3) and Z1 = Z(Z2Z3), information encodedinto this code can be accessed by making a measurementon the first qubit. Similarly, information encoded intothe second code, S2, is localized in the third qubit. The

adiabatic evolution in Eq. (4) can now be seen as adiabat-ically dragging a Hamiltonian that is a sum over stabilizergenerators in S1 to a sum over stabilizer generators in S2

such that the information in the encoded qubit describedby X and Z is not touched.

To analyze how the dragging between S1 and S2 oc-curs, it is useful to introduce a new code, S3. This codehas no non-identity stabilizer operators, but has threeencoded qubits. These are defined by

X1 = X1X2 Z1 = Z2Z3

X2 = X2X3 Z2 = Z1Z2

X3 = X1X2X3 Z3 = Z1Z2Z3 (5)

Notice that Z1 and X2 are the stabilizer generators ofS1 and X1 and Z2 are the stabilizer generators for S2.From this perspective, then, the adiabatic evolution isfrom the initial Hamiltonian −∆(Z1 + X2) to the finalHamiltonian −∆(X1 + Z2). These are then simple in-terpolations between single operators on encoded qubits,and will have a constant energy gap. Indeed, both S1 andS2 can be turned into S3 by promoting stabilizer gener-ators in these codes to logical Pauli operators. When itis possible to perform such a change between codes viaan adiabatic evolution, we say that we can adiabaticallydeform one code into the other. This technique is at theheart of the constructions in this paper.

To see that the information encoded in the first qubitends up at the third qubit, first note that, during theabove evolution, the third encoded qubit is not involved.This implies that information encoded into this qubitwill not be affected by the evolution. Next note thatX1 = X3X2, Z1 = Z3Z1 and X3 = X3X1, Z3 = Z3Z2.Recall that we are dragging between the +1 eigenstateof X2 and Z1 to the +1 eigenstate of Z2 and X1. Thus,since information encoded into the third qubit is notchanged during the above evolution, we see that the pro-tocol transports the information in the first qubit to thethird qubit.

More generally, the AGT protocol can be extended toenable universal quantum computation [7]. We omit thedetails of this construction except for noting that evenwhen generalized, the energy gap used to guarantee adi-abatic evolution is a constant with respect to the numberof qubits in the system. We will often refer to this bysaying that the energy gap of an adiabatic evolution isconstant when considered by itself—we use this languagemerely to imply that stringing together similar parallelevolutions will not shrink the gap as a function of thenumber of qubits involved in the evolution.

IV. ADIABATIC CODE DEFORMATIONS OFTHE SURFACE CODE

With the punctured surface code defined, we nowpresent a series of adiabatic code deformations that al-low for a nearly universal set of operations. First, we

7

show how to prepare a surface code without any defects.Next, we show how to prepare smooth defects in the +1eigenstate of Z and rough defects in the +1 eigenstateof X. We then show how to prepare smooth defects in±1 eigenstates of X and rough defects in ±1 eigenstatesof Z. (These procedures prepare the defects in eigen-states of the string-like logical operators that tether thedefects to a boundary.) Following this, we introduce aprocedure to allow code regions containing defects to beseparated from and attached to the rest of the code. Wenext show how defects can be deformed, allowing them tobe moved around the lattice. This additionally allows forthe CNOT to be enacted between a smooth and a roughdefect. Finally, we show how arbitrary ancilla states canbe injected into defects and utilized in a computation.

The procedures above can be performed in an entirelyadiabatic fashion and thus benefit from the protection ofa Hamiltonian gap. Additionally, procedures like defectbraiding also benefit from the topological nature of thesurface code Hamiltonian, with logical errors requiringhigh-weight, correlated physical errors corresponding tonontrivial cycles on the lattice or dual lattice. We men-tion this now to highlight the difference between the en-tirely adiabatic operations presented in this section andoperations we present in Sec. V—such as measurement orheralded gate application—that do not inherit any pro-tection from the gap or the topology.

A. Creation of a surface code without defects

We begin by assuming that we have a large array ofqubits, shown in Fig. 4, stabilized by a Hamiltonian Hi

given by

Hi = −∆∑

j

Zj , (6)

where the sum runs over all the qubits. The ground stateof this Hamiltonian is unique and has all the qubits inthe state |0〉. To prepare the surface, standard activeerror correction techniques call for the stabilizer genera-tors to be measured. Here, we simulate these measure-ments in the vein of the “forced measurements” intro-duced in Ref. [14] by slowly turning off Hi and turningon the Hamiltonian introduced in Eq. (1) for the specificinstance of a “small” surface code. Turning on a Hamil-tonian with a “large” surface code as the ground statewould cause the system gap to shrink proportionatelywith the size of the code, so to be concrete we chooseto evolve initially to a Hamiltonian with a small surfacecode ground state. (We will subsequently show how itssize can be sequentially increased.) In other words, we

FIG. 4: A large array of qubits in the state |0〉, each protectedby a Hamiltonian H = −∆Z.

adiabatically follow the Hamiltonian

H(t) =

(1− t

T

)∑

j∈Q(−∆Zj) +

t

T

∑

S∈G

(−∆

2S

)

+t

T

∑

j 6∈Q(−∆Zj) , (7)

where Q is the set of qubits participating in the surfacecode terms. In this case, G has 8 elements, the fourplaquette operators and the four vertex operators shownin Fig. 5. Provided T is large, the system will remain inthe ground state. As we showed before, the ground stateof the Hamiltonian in Eq. (1) is the codespace if a surfacecode. We choose it to be nondegenerate by our choice ofboundaries, although this is not a necessity. After theevolution, the array of qubits looks like Fig. 5.

Having created a small surface code that encodes noqubits, we can increase its size by modifying the bound-aries adiabatically. For example, we can grow out part ofthe smooth boundary by performing an evolution of theform

H(t) =

(1− t

T

)(−∆Z1 −∆Z2 −∆Z3)

+t

T

(−∆

2Z1Z2Z3 −

∆

2X1X2 −

∆

2X2X3

), (8)

where the numbering corresponds to Fig. 6. This alsorequires the modification of vertex checks on the smoothboundary being extended, which can be performed at thesame time. Additionally, a similar procedure will allow

8

FIG. 5: A large array of qubits, an 8-qubit region of whichis now encoded in the surface code (shown in black). Theboundaries of the code are chosen to be trivial so that thecodespace is nondegenerate.

the extension of rough boundaries. By piecing these ad-ditional evolutions together, a larger surface code regioncan be constructed while maintaining a Hamiltonian gapthat is lower bounded by a constant proportional to ∆.

For the remainder of this section, we will specializeour figures so that they do not include the black dotsthat represent qubits, instead keeping only the underly-ing square lattice structure of the code. However, the fullplane of qubits is still assumed to exist.

B. Creation of a small Z (X) defect in a +1eigenstate of Z (X)

Here we describe how to create a two-plaquette smoothdefect in an unpunctured surface code. (The creation ofa rough defect will proceed in an exactly analogous waywith the roles of Z and X interchanged.) We create de-fects using two neighboring plaquettes for pedagogicalclarity, although creating single defects is also possible.With two-plaquette defects, it is obvious that the cre-ation process inherits protection from a Hamiltonian gapand the topological nature of logical operators; for single-plaquette defects, the Hamiltonian gap protection is notpresent.

To begin the creation procedure, the Hamiltonian isinitially given by Eq. (1), the negative sum of all the pla-quette and vertex stabilizer generators for the code. Thedefect will consist of two adjacent plaquettes, bounded by

1

2

3

FIG. 6: Growth of a small surface code region that involvesonly the qubits labeled 1, 2, and 3.

a curve c that encloses these plaquettes. If the stabilizergenerators associated to these two plaquettes are Sp1 and

Sp2 , we can promote them to Z operators for two encoded

qubits—Zp1 and Zp2 respectively—of a new code wherethe stabilizer generators Sp1 and Sp2 have been removed.

If we do this, then X for each qubit can be chosen as astring of Pauli X operators beginning on the appropriateplaquette, traversing the dual lattice, and ending on asmooth boundary (see Figure 7). In fact, we can alwayschoose these operators so that they overlap on all but thequbit separating the two plaquettes. We call these twoencoded logical X operators Xp1 and Xp2 . The operator

Xp1Xp2 is then the single Pauli X operator acting on thequbit between the plaquettes.

Suppose that we now perform the following adiabaticevolution: while turning off the two plaquette operators,Sp1 and Sp2 in the Hamiltonian, we simultaneously turnon the Pauli X operator between these two plaquettes.In terms of the encoded logical operators we have definedabove, this is equivalent to starting with the Hamiltonian

Hi = −∆

2(Sp1 + Sp2) = −∆

2(Zp1 + Zp2) (9)

and ending with the Hamiltonian

Hf = −∆

2Xp1Xp2 (10)

All the other terms in the Hamiltonian commute withthe relevant operators and therefore do not contribute toany spectral shifts that might cause crossings.

9

p1 p2

Sp1= Zp1

p1 p2

p1 p2p1

Sp2= Zp2

p2

Xp1Xp2

FIG. 7: Operators involved in creating the defect that in-cludes p1 and p2. Note that the X operations span to a nearbysmooth boundary.

In order to understand what happens in interpolatingbetween Hi and Hf , it is convenient to note that Zp1Zp2(which is a closed loop of Pauli Z operators surroundingthe smooth defect we are creating) commutes with theseHamiltonians. Also note that initially the system is inthe +1 eigenstate of both Zp1 and Zp2 , and hence also in

the +1 eigenstate of Zp1Zp2 . Because Zp1Zp2 commuteswith both Hi and Hf , we may work in a basis in which

Zp1Zp2 and the full Hamiltonian are simultaneously di-agonal. This commutativity ensures that the eigenvalueof Zp1Zp2 is conserved throughout the evolution. If weperform this evolution via a simple adiabatic draggingbetween these Hamiltonians (as described in Section III)then the energy gap in the system during this evolutionremains constant. At the end of the evolution, the sys-tem is in the +1 eigenstate of both Zp1Zp2 and Xp1Xp2 ,which is simply a single Pauli X on the qubit betweenthe plaquettes.

The above can be interpreted in terms of codes. Byturning off two stabilizer generators and turning on onlya single Pauli X, we have introduced an encoded qubitby decreasing the number generators. The product ofthe two missing plaquette checks is Z, and either Xp1

or Xp2 can be chosen as X. Additionally, because the

operator Z commuted with the Hamiltonian throughoutthe adiabatic evolution, the encoded qubit is prepared inthe +1 eigenstate of Z.

After this adiabatic evolution, the Hamiltonian doesnot quite factor into two separate codes on the interior

and exterior of the defect. The vertex operators adjacentto the defect region still check the single qubit on theinterior. As a generating set, the four-body checks ad-jacent to the defect and the single-body “check” on theinterior qubit can equally well be thought of as a gener-ating set with two three-body operators that do not acton the interior qubit, and the single-body operator thatdoes. However, in the Hamiltonian framework we mustexplicitly remove support of these four-body checks onthe interior qubits. We do this either by including themodification of the adjacent vertex checks in the evolu-tion discussed above, or by using another evolution af-terward that performs the modification. We will assumethat the former modification is used.

We note at this point that, while the defect we havecreated is small and thus susceptible to relatively low-weight loops of Z errors, these errors actually have noeffect. Since Z acts trivially on the state we haveprepared—namely, |0〉—the fact that the defect has asmall perimeter is not detrimental. Once we start per-forming gates that change the state, we will have to makesure that the perimeter is large, and that the defect is farfrom the boundaries and other defects.

As mentioned above, the same arguments can be madefor preparing rough defects in the +1 eigenstate of X. Inthat case, two adjoining vertex checks are turned off whilea single-body Z on the qubit in the middle is turned on.Two adjacent four-body Z checks have to be modifiedin this case, but the arguments are exactly the same asabove.

It might be useful to address a question that may haveentered the reader’s head. The procedures above adia-batically interpolate between a Hamiltonian with a non-degenerate ground space to a Hamiltonian with a degen-erate ground space. Isn’t there a level crossing betweenthe ground space and an excited space that can causetransitions away from the state we want to prepare? Pro-tection from this coupling is provided by the topologicalnature of the logical operators. The only operator thatcan couple |0〉 and |1〉 for a smooth defect is the string-likeoperator X that connects the defect to a boundary. Thisamounts to another way of saying that the eigenvalue ofthe operator Z is a conserved quantity throughout theevolution, and so such a crossing is not meaningful.

Now that we have introduced a method for creatingsmooth defects in the +1 eigenstate of Z and rough de-fects in the +1 eigenstate of X, we will show how thesedefects can be grown and moved around the lattice. Thiswill allow us to introduce other procedures, such as theisolation of a defect from the bulk of the code and an adi-abatic code deformation that performs a CNOT gate.

C. Adiabatic deformation of defects

We now show how to deform a defect. This involvesmodifying the Hamiltonian by adding or removing stabi-lizer generators, the combination of which allows defects

10

to be moved.Consider a smooth defect that we wish to grow by turn-

ing off a single adjacent plaquette check in the bulk ofthe system. The number of edges bordering the interiorof the defect is either 1, 2, 3, or 4, as shown in Fig. 8.The procedure in each case is basically the same, with

(a) (b)

(c) (d)

FIG. 8: The four potential situations faced when growing asmooth defect. (a) Only one interior qubit. (b) Two interiorqubits. (c) Three interior qubits. (d) Four interior qubits.

the clean-up or potential removal of the adjacent vertexchecks being the only difference. The growth is achievedby turning off the plaquette check in the Hamiltonianand turning on a single-qubit −∆

2 X Hamiltonian for eachqubit in the interior after the evolution. We also modifyany adjacent vertex checks at the same time to make thecode factor properly into an interior and an exterior. Wewill briefly analyze the different interior edge cases.

For a single interior edge, as shown in Fig. 9, thereis not much different with respect to the case of defectcreation. As the plaquette check to grow into is turnedoff, a single-body X on the qubit adjacent to the defectand the plaquette is turned on. To fully sever the interiorand exterior regions, the only thing left to do is modifythe two adjacent vertex checks from three-body operatorsto two-body operators.

The cases of 2, 3, and 4 interior edges are different inthat some vertex checks are not only modified but areturned off completely. For the case of 2 interior edges,as shown in Fig. 10, the appropriate evolution turns offthe plaquette check while turning on two single-body XHamiltonians on the interior edges. Note that the two-body vertex check that operated on both the interiorqubits is now redundant in terms of stabilizer generators:it is simply the product of the two single-body X termsthat were turned on. As such, it can simply be turned

(a) (b)

(c) (d)

�X

�ZZZZ

�XX

�XXX

FIG. 9: Growth of a smooth defect with only a single qubiton the interior after the procedure. (a) We wish to growthe defect to the indicated plaquette. (b) We adiabaticallyturn off the neighboring plaquette while (c) turning on a −XHamiltonian on the interior qubit. (d) This procedure causesmodifications to the neighboring X checks that can be per-formed simultaneously with steps (b) and (c).

off without having to worry about the codespace beingaffected; it merely provides an additional energy penaltyfor errors on the two interior qubits. The result is thatwe have removed two stabilizer generators—the plaque-tte check and the two-body vertex check—and added twostabilizer generators—the two single-body X operators.Thus, we have not added any additional logical qubits,we have merely grown the perimeter of an existing one.As a final note, the two adjacent four-body vertex checksalso must be modified to three-body checks, and again,this can happen simultaneously with the other adiabaticevolutions. The case of 3 and 4 interior qubits, shown inFig. 11 and Fig. 12 respectively, is almost identical. Forthe case of 3, the plaquette check is turned off while threesingle-body X Hamiltonians are turned on. In this case,two weight-two vertex checks are now redundant, and asbefore they can simply be turned off without worryingabout level crossings. The counting works in a similarway, in that we have removed three stabilizer genera-tors and added three, preserving the number of logicalqubits. The two adjacent weight-four vertex checks alsoget modified to weight-three operators. Finally, in thecase of 4 interior qubits, the same adiabatic deformationis performed: the plaquette check is turned off and foursingle-body X Hamiltonians are turned on. Only three ofthe two-body vertex checks are independent, and so onlythose three appeared in the original Hamiltonian. Theyare the three checks made redundant by the single-body

11

(a) (b)

(c) (d)

�X

�ZZZZ

�XXX�X

�XXX

FIG. 10: Growth of a smooth defect with two qubits on theinterior. (a) We wish to grow the defect to the indicatedplaquette. (b) We adiabatically turn off the neighboring pla-quette while (c) turning on two −X Hamiltonians on the in-terior qubits. (d) This procedure causes modifications to theneighboring X checks.

X Hamiltonians in this case. Unlike the other cases, inthis case there are no other vertex checks that need to bemodified.

The procedure for shrinking defects is simply the in-verse of the procedures introduced above. By combiningthe “grow” and “shrink” operations, we can move de-fects. As demonstrated in Ref. [60], an encoded CNOTgate can be performed by moving a smooth defect in afull loop around a rough defect. The smooth defect isthe control and the rough defect is the target, and thedirection of movement—clockwise or counterclockwise—is unimportant.

D. Detaching and attaching surface code regionswith defects

For some subsequent procedures we will consider, it ishelpful to have an operation that isolates a defect fromthe surface code or reintroduces a defect to the surfacecode that was previously isolated. By using defect cre-ation and growth operations described in Secs. IV B andIV C, we can grow a defect “moat” around a defect of in-terest so that the “castle” surrounding the defect has justa single “drawbridge” connecting it to the rest of the sur-face, as depicted in Fig. 13. The only additional opera-tion we must consider to complete the isolation procedureis how to “lift the drawbridge” by modifying the remain-ing check operators adjacent to it. As before, we will

(a) (b)

(c) (d)

�X

�ZZZZ

�XXX

�X

�XXX

�X

FIG. 11: Growth of a smooth defect with three qubits onthe interior. The process is essentially the same as the onedepicted in Fig. 10.

(a) (b)

(c) (d)

�X

�ZZZZ

�X �X

�X

FIG. 12: Growth of a smooth defect with four qubits on theinterior. The procedure is the same as the others, but thereare no resulting X check modifications.

only consider the case of manipulating smooth defects—the case for rough defects is similar.

To isolate smooth defect, we must use smooth bound-aries on the “castle” to ensure that X for the defect willhave a place to terminate once the “drawbridge” is lifted.For concreteness, we assume that this smooth boundary

12

· · ·

· · ·

1

2

FIG. 13: The setup for pinching off a smooth defect from asmooth wall.

corresponds to the large boundary of the surface, butthe same procedure could be performed using a defect tocreate the isolated region.

To remove the “drawbridge,” we simply turn off thesingle plaquette check that connects the two regions whileturning on a single-body X on each of the two qubits thatneed to be removed. (These qubits are labeled 1 and 2in Fig. 13.) The operator X1X2, which was an elementof the stabilizer group before the evolution, is now re-dundant, just as in the case of the interior checks thatappear during defect growth in Sec. IV C, and it is alsoremoved. Thus, we remove two checks—the check as-sociated with the “drawbridge” and the two-body checkX1X2—and replace them with two single-body X checksin the Hamiltonian. As before, the vertex checks adja-cent to the “drawbridge” must be modified, and in thiscase they become three-body operators. (As a closingaside, if we had tried to detach a smooth defect througha rough boundary, the operator X1X2 would no longerhave been an element of the stabilizer group.)

Reversing the detachment procedure allows regionswith defects to be attached to to the surface, introduc-ing (or reintroducing) isolated defects back into the code.This attachment procedure is an important step in ourprotocols for making measurements of X and Z and in-jecting ancilla states into the system, as discussed inSec. V A and Sec. IV F. It is also possible to isolate andreintroduce a rough defect through a rough boundary inan analogous fashion.

E. Creation of a X (Z) defect in a ±1 eigenstate ofZ (X)

Another capability that will be useful for later proce-dures is the ability to prepare rough defects in an eigen-state of Z and smooth defects in an eigenstate of X. Thepreparation of these defects in performed in a region thatis disconnected from the main surface. It is then attachedto the surface using the procedure described in Sec. IV Dto introduce it to the bulk surface.

To prepare a rough qubit in the +1 eigenstate of Z,we utilize a procedure very similar to the original cre-ation of the surface, described in Sec. IV A. Recall thatthe stabilizer Hamiltonian on a region disconnected fromthe surface is simply a sum of single-body −Z operatorson each qubit. Once the location and size of the discon-nected region is chosen, we prepare it in a surface withsolely rough boundaries. Rather than following this upwith the creation of a rough defect, we simply prepare thesurface by leaving a region of adjacent X checks turnedoff and the single-body Z terms on the interior of the re-gion unchanged. Since the system began in an eigenstateof any product of Z operators, and since Z for the roughqubit commutes with all of the check operators we turnon, the system remains in the +1 eigenstate of Z afterthe evolution.

We also could have prepared the rough defect in the−1 eigenstate of Z by first performing an adiabatic evo-lution on each qubit of the form −Z → X → Z. Thishas the effect of dragging each of the qubits into the −1eigenstate of the local Z operators, and now, given a re-gion of appropriate size, Z will have an eigenvalue of −1both before and after the defect creation process. (Thesize constraints amount to ensuring that the weight ofthe logical operator is odd.)

Smooth defects can be prepared in ±1 eigenstates ofX in much the same way, requiring only simple modifi-cations. To prepare a smooth defect in the +1 eigenstateof X, each qubit first undergoes the evolution induced bythe adiabatic sequence −Z → −X. Likewise, to preparea smooth defect in the −1 eigenstate of X, each qubitfirst undergoes the adiabatic evolution −Z → X. NowX will have the correct value before and after the evo-lution that creates the defect, subject to the same sizeconstraints mentioned above.

F. State injection into defects

Creating defects in known ancilla states is another im-portant building block for our model. In typical archi-tectures based on the surface code, completing a uni-versal set of encoded quantum gates requires the abilityto “distill” high fidelity states—called “magic states”—using protocols like the one discovered by Bravyi andKitaev [49]. In this section, we describe how to imple-ment these preparations in an adiabatic simulation of theprocess of state injection.

13

In measurement-based injection of a magic state [36],one first exposes a qubit by preparing a single (unen-coded) qubit in the state |ψ〉. Then, the state is quicklyencoded in a surface code defect, and the procedure isfinished by growing the defect to a sufficiently large sizeso that it is well protected from noise. This process neednot be perfect, but any error introduced by the injectionprocedure must keep the total error in the encoded state|ψ〉 below the threshold of the distillation protocol.

We describe our adiabatic simulation of this process foran injection into a smooth defect, but the rough-defectcase is similar. We begin by preparing an all-smooth-boundary surface near the edge of the bulk surface us-ing the method described in Sec. IV A. We then create arough defect in a +1 eigenstate of X in this region usingthe procedure described in Sec. IV B. The situation is de-picted in Fig. 14. Because this region has only smooth

· · ·

· · ·

...

...FIG. 14: After the Hamiltonian deformation (or sequence ofdeformations), we are left with a surface code with trivialboundaries encoding a rough defect in the state |+〉.

boundaries, there is nowhere for a string of X operatorsfrom the defect to connect. Indeed, if we ignore the onequbit on the interior of the defect, then what we wouldnormally call X, a string of X operators enclosing thedefect, is already an element of the stabilizer group. Itcan be formed by taking the product of all the vertexchecks. (As an aside, we note that this is a consequenceof the topology of the sphere, for which all loops remainhomotopic when a single point is removed.) As discussedin Sec. IV B, this leaves the single qubit on the interiorof the defect in the +1 eigenstate of Z.

We then transform this interior qubit to the desiredstate by an adiabatic evolution. For example, if we wantto prepare the state T |+〉, we evolve using the Hamilto-nian H(s) = (1 − s)(−Z) + sUZU†, where in this caseU = TH. If we think of this as a logical qubit, then X isa single X on the qubit and Z is a single Z on the qubit.

Recall that the face checks originally incident on the in-terior qubit have been modified and are no longer inci-dent. The situation is now described by Fig. 15. Next,

| i

· · ·

· · ·

...

...FIG. 15: The interior qubit is adiabatically dragged to thestate |ψ〉, the desired magic state.

we adiabatically turn on the two vertex checks that wereoriginally turned off to create the defect. We simulta-neously (and adiabatically) also turn off the three-bodyplaquette checks, as they would otherwise anti-commutewith the final Hamiltonian. This evolution transformsthe logical operators, since the initial single-body Z doesnot commute with the final X checks. The transforma-tion Z undergoes is determined by the Pauli algebra andthe demands of a stabilizer code. Since Z must still com-mute with the code after the vertex checks are turnedback on (note that the formerly interior qubit has nowbeen reintroduced to the code because the vertex checksare incident on it once again), and since it also must notbe in the stabilizer group itself, a suitable choice of thenew Z is the product of the old Z and one of the three-body plaquette checks that also did not commute withthe vertex checks. What remains is what appears to bea normal two-plaquette defect as shown in Fig. 16, butthe crucial difference is that there is now no sense of anisolated interior, since the neighboring vertex checks arestill incident on the qubit inside. In fact, because X hasnever been disturbed by any of the evolutions we per-formed, it is still a single-body operator localized to thequbit inside the defect. This leaves the encoded qubitprone to decohering environmental interactions, and sowe make it larger by “splitting” the defect apart into apair of defects, as depicted in Fig. 17. As we move theparts away from each other, we also grow their perimetersusing the methods described above to protect against Zerrors.

This double-defect qubit could be used as-is, but tomake it more like the defects we have worked with so far,

14

· · ·

· · ·

...

...FIG. 16: The missing X checks are reintroduced to the code,causing neighboring Z checks to be removed. This new defectis now encoded in the state |ψ〉 with an encircling Z and asingle-qubit X.

· · ·

· · ·

...

...FIG. 17: Because X was only a single-qubit operator, thetwo removed faces are moved apart and grown to combatdecoherence.

we simply take one of the halves and merge it with theglobal smooth boundary of our preparation region, as de-picted in Fig. 18. Finally, we attach the surface contain-ing this defect to the main surface using the proceduredescribed in Sec. IV D. This defect can be shuttled in andthe boundary can be modified to the original shape.

Encoded distillation circuits, such as the ones depictedin Figs. 19 and 20 (where the S and T gates are imple-mented by teleportation circuits such as the one depictedin Fig. 23), utilize operations we have already described:

· · ·

· · ·

...

...FIG. 18: One of the defects is merged with the boundary tomake the standard single defect.

preparation of defects in |0〉, |+〉, T |+〉, and S|+〉 statesand implementation of CNOT gates by code deforma-tion. The only encoded operations these circuits use thatwe have not described are measurements of encoded PauliX and Z operators, which we describe in Sec. V A.

V. NON-ADIABATIC PROCEDURES FORSURFACE CODE DEFECTS

The procedures presented in Sec. IV use only adiabaticevolutions of stabilizer Hamiltonians. However, these op-erations do not allow for universal quantum computation.The key missing ingredient is the capability to performlogical measurements—namely, the ability to measure Xand Z for smooth and rough defects. These measure-ments are the only non-adiabatic ingredients appearingin our model. In this section we describe how to per-form them as well as use them in additional procedures,such as heralded application of X and Z gates. Althoughthe measurements are not protected by adiabaticity or aHamiltonian gap, their topological nature provides ro-bustness to local errors.

A. Measurements of X and Z for defects

In measurement-based surface-code models, defect log-ical operators are measured in-situ by simply measuringa region of individual qubits in the surface. The paritiesof of the measurements are then used to infer the eigen-value of X or Z with probability 1 − O(pd), where d isthe distance of the code and p is the probability that anindividual qubit measurement is faulty. In our Hamilto-nian model, this in-situ measurement is an issue because

155

The equivalent post-decoding-circuit Z-check measure-ments become elaborate entangled measurements thatcannot be reconstructed by simply measuring each qu-bit individually, despite suggestive circuits drawn in theliterature [27, 69].

A clever alternative by Raussendorf et al. obviates theneed for measuring complicated operators by encodinghalf of a Bell state and processing it to distill the outputon the other half [26]. Their protocol is as follows:

1. Prepare the state |�+i := (|00i + |11i)/p

2.

2. Send half of |�+i through the coherent encodingcircuit for QRM(1, 4).

3. Prepare the state (T |+i)⌦15.

4. Apply A with probability 1/2 on each of these 15qubits.

5. Teleport the T gate from each of these “twirled”T |+i states to a corresponding qubit on the en-coded half of |�+i.

6. Measure MX on each of the 15 encoded qubits.

7. Infer the X-check values from the appropriate prod-ucts of these MX measurements. Declare failure ifthe X-check syndrome is not 0. Otherwise, proceedto the next step.

8. Infer the logical X value for QRM(1, 4) by takingthe product of all of the MX values. If it is �1,apply Z to the other half of the original Bell state.The unmeasured half of the original Bell state isT †|+i with a higher fidelity.

The inclusion of the twirl operation is omitted byRaussendorf et al. and by many others who have builtupon this protocol [70, 71]. However, twirling is essentialin the analysis by Bravyi and Kitaev in deriving Eq. (11)below for the accuracy of the distilled output state:

✏out(✏) =1 � (1 � 2✏)7(30✏+ (1 � 2✏)8)

2(1 + 15(1 � 2✏)8)(11)

⇡ 35✏3. (12)

That said, Jochym-O’Connor et al. have discovered thatmagic-state distillation works at least as well, and maybeeven better, when twirling is omitted in a distillationprotocol based on the five-qubit code [64]. Inspired bythis result, we too omit the twirling circuits from theprotocol yet still use the Bravyi-Kitaev formula as a sortof loose guideline for how much the fidelity has improved,expecting that the fidelity increase may even be better.

A quantum circuit that implements the Raussendorfet al. protocol is depicted in Fig. 2.

The final Z correction from step 8 that may need tobe applied is not depicted in Fig. 2 because it can beincorporated into the subsequent teleportation circuit in

|+i • T MX

|+i • T MX

|+i • T MX

|+i • T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|0i ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ ⌫��⇣⌘✓◆ T MX

|+i • T † |+iFIG. 2: Distillation circuit for T †|+i states, adapted fromRef. [26]. After the Bell state preparation, the gates performthe coherent encoding circuit for the 15-qubit shortened quan-tum Reed-Muller code. (See Appendix A for details.) The Tgates are performed by gate teleportation, using the circuitfrom Fig. 1. This distillation circuit also distills T |+i stateson T †|+i inputs.

Fig. 1 instead at a lower gate cost. To do this, the fi-nal corrective step in Fig. 1 must depend on both theMZ measurement there and the measurement indicatingwhether the Z operator needs to be applied. The set ofpossible corrections is then I, Z, S, and SZ = S†. Thenumber of gates in the teleportation circuit is then 3.75on average instead of 3.5. The worst-case gate count isstill 4, however.

Let us now count the number of gates used by theRaussendorf et al. protocol.

To achieve ✏out ✏T , one iterates this distillation pro-cess ` times, where

`(✏T , ✏) =

⇠log ✏T

log ✏out(✏)

⇡. (13)

In addition to this, each of these rounds must them-selves be repeated t times because the X checks mayfail to give a trivial syndrome. Because low-error statesdecode with higher probability, the expected number ofrepetitions is small when ✏ is small. Specifically, the ex-

FIG. 19: Distillation circuit for T |+〉 states, constructed fromthe 15-qubit Reed-Muller code’s encoding circuit.

single-qubit measurements in the surface will necessarilyanti-commute with the code Hamiltonian, leading to ex-citations out of the ground space. If it is the end of thecomputation, and we want to know the state of all thedefect qubits, we can just turn the Hamiltonian off andmeasure everything. However, the use of magic statesvia gate teleportation (described later) requires condi-tioning future actions on the classical outcome of log-ical qubit measurements. In this section we present anancilla-coupled method to perform these logical measure-ments.

To measure X or Z for a defect in a “non-destructive”way (meaning that the post-measured state stays in thecodespace), we use the method of ancilla-coupled mea-surement introduced by Steane in Ref. [61]. Fig. 21 de-picts this process for measuring Z for a smooth defectqubit in the state |ψ〉. First, we prepare a rough defect inthe +1 eigenstate of Z as described in Sec. IV E. Next, weperform a sequence of adiabatic deformations, describedin Sec. IV C, to enact a CNOT gate between the smoothand rough defects. Then, the rough-defect ancilla is de-tached from the code using the method demonstrated in

|+〉 • S MX

|+〉 • S MX

|+〉 • S MX

|0〉 S MX

|0〉 S MX

|0〉 S MX

|0〉 S MX

|+〉 • S† |+〉FIG. 20: A distillation protocol for S |+〉 states based on theencoding circuit for the [[7, 1, 3]] quantum Steane code.

|ψ〉smooth •

|0〉rough Z

FIG. 21: An example of measuring Z for a smooth qubit. Itrequires the preparation of a rough defect in a +1 eigenstateof Z, as discussed in Sec. IV E.

Sec. IV D. Finally, we turn off the Hamiltonian and de-structively measure the isolated region in the Z basis.A similar procedure performs a measurement of X for asmooth qubit (simply measure the isolated region in theX basis), and a similar circuit can be used to measurelogical operators for a rough defect.

B. Heralded application of X and Z to defects

With the ability to perform ancilla-coupled measure-ments, introduced in Sec. V A, and the Hamiltonian evo-lutions described in Sec. IV, we can apply X and Z todefects using the circuit shown in Fig. 22, where the mea-surements are assumed to be of the type described inthe previous section. These operations are not necessaryto establish universality; the set of encoded operationswe have presented thus far are a universal set by them-selves. In fact, there is never a need to apply logicalPauli operators at all using our encoded gate basis be-cause logical Pauli operators can be propagated throughencoded circuits efficiently by the Gottesman-Knill the-orem [62]—the only non-Clifford gate in our gate basisis the preparation T |+〉, and Pauli operators never needto be propagated through preparations. The propagated“Pauli frame” can then be used to reinterpret measure-ment results as needed, without active application of log-ical Pauli operators. Nevertheless, we present methodsfor applying logical Pauli operators in case there is a sit-uation where propagating the Pauli frame is undesirable.

16

|ψ〉smooth • MX • XaZ

b |ψ〉

|0〉rough MZ

FIG. 22: Circuit used to apply one of the Pauli operatorsto a smooth defect qubit. The outcome of the X measure-ment is b ∈ {0, 1} and the outcome of the Z measurementis a ∈ {0, 1}. The outcomes of the measurement all occurwith equal probability and the final state depends on theseoutcomes as shown. If an undesired operator is applied, theancilla qubit is reinitialized and the circuit is implementedagain. However, now the appropriate operator is the one thatundoes the operator applied in the first iteration and appliesthe desired operator. (This, of course, will just be a different

one of the four operators XaZ

b.)

All of the pieces in this circuit have been describedpreviously. The preparation of a rough defect in the +1eigenstate of Z is described in Sec. IV E, performing aCNOT between a smooth defect and a rough defect isdescribed in Sec. IV C, and making measurements of Xand Z for smooth and rough defects was just describedin Sec. V A.

VI. THE COMPLETED MODEL

To summarize our surface code model, we list the pro-cedures we have defined in Sec. IV and Sec. V:

1. Sec. IV A: Adiabatic preparation of a surface codeencoding no qubits

2. Sec. IV B: Adiabatic preparation of smooth defectsin the +1 eigenstate of Z and rough defects in the+1 eigenstate of X

3. Sec. IV C: Adiabatic deformation of smooth andrough defects, allowing for defect movement

4. Sec. IV D: Adiabatic detaching and attaching pro-cedures, allowing for the isolation of regions con-taining defects

5. Sec. IV E: Adiabatic preparation of smooth defectsin the ±1 eigenstate of X and rough defects in the±1 eigenstate of Z

6. Sec. IV F: Adiabatic injection of ancilla states intodefects

7. Sec. V A: Non-adiabatic procedures for “non-destructive” ancilla-coupled measurement of X andZ for defects

8. Sec. V B: Non-adiabatic, measurement-based pro-cedure for the heralded application of X and Z

Magic-state gate teleportation of the T gate is performedusing the circuit in Fig. 23, and the Hadamard gate canbe performed with an ancilla state using the circuit inFig. 24. In both cases, the only operations required

|ψ〉 • S T |ψ〉

T |+〉 Z •

FIG. 23: Gate teleportation circuit using the T |+〉 state. TheS correction needs to be performed half of the time and canbe implemented in the same way using the state S |+〉 = |+i〉instead of T |+〉 (and utilizing a Z correction half of the time).

|ψ〉 S S† A H |ψ〉

|+〉 • S X •

FIG. 24: Circuit for applying the Hadamard gate with anancilla state. The correction A depends on the result of themeasurement: if the measurement result is +1, then A = X,and if the measurement result is −1, then A = Z. The Sand S† gates can be performed using a circuit like the one inFig. 23.

involve the procedures defined in the list above. Otherprocedures, such as performing a CNOT between twosmooth qubits, have been studied previously [36] and alsoonly require operations from the list above. Thus, inencoded form, we can prepare Pauli X and Z eigenstates,perform a universal gate set, and measure any qubit ineither the X or Z basis. Taken together, these proceduresallow for universal quantum computation.

VII. EXTENSION TO 2D COLOR CODES

We briefly discuss how one can adapt our surface codeprocedures to the two-dimensional color codes, in partic-ular to the 4.8.8 2D color code. This extends our con-struction to all nontrivial homological stabilizer codes,because by Anderson’s classification theorem [63], all ho-mological stabilizer codes with nonlocal logical operatorsare either surface codes or color codes.

Color codes in two dimensions are defined on a two-dimensional lattice that is trivalent (each vertex is ofdegree three) and face-three-colorable (we can color theplaquettes by three colors such that no two adjacent pla-quettes are the same color). In such a graph, the edgescan also be colored to be the color that is different fromthe colors of the two faces incident upon it. Fig. 25 is

17

FIG. 25: A lattice with colored plaquettes on which one candefine the color codes.

an example of such a lattice. Unlike our presentation ofthe surface code in which graph edges were associatedwith qubits, color codes are naturally presented so thatgraph vertices are associated with qubits. Let V (p) de-note the vertices that are on the boundary of a plaquette,and define a stabilizer group structure of the color codesas follows. To every plaquette p, associate two stabilizergenerators, the tensor product of Pauli X on the adjacentqubits, given by

SXp =⊗

v∈V (p)

Xv, (11)

as well as the tensor product of Pauli Z on the adjacentqubits, given by

SXp =⊗

v∈V (p)

Zv. (12)

The representative code in Fig. 25 has four-body (red)and eight-body (blue and green) stabilizer generators.(These are the weights away from the boundaries of thecode, where four-body blue and green faces also exist.)Boundaries in the color code also have a slightly richerstructure. They are no longer smooth and rough, butrather, they have a color associated to them. This color isdetermined by the boundary’s missing color. For exam-ple, in Fig 25, the bottom boundary is red, since there areno red plaquettes adjacent to the bottom edge. A carefulaccounting of qubits and checks in Fig. 25 indicates thatthere is a single logical qubit associated with the surface.For our purposes, we will treat it as a “gauge” degree offreedom using the subsystem stabilizer code formalism[19]. The operators X and Z associated with this qubitcan be chosen as strings of Pauli X and Z operators,respectively, along the bottom boundary.

Just as with the surface codes, we can create defects inthe color code to store more logical qubits. In additionto having a type (X or Z), the defects now also have acolor. To create the analog of a smooth defect, we removea Z-type stabilizer generator, and to create the analog ofa rough defect, we remove an X-type generator. For aZ-type defect, one choice for Z is the removed genera-tor (equivalent to a string of a different color around the

defect that only passes through edges and faces of thatcolor), and one choice for X is a string of Xs connect-ing to a boundary whose color is the same as that ofthe removed plaquette (such that the string only passesthrough edges and faces of the same color as the removedplaquette).

As is true for any stabilizer code, we can define theHamiltonian in Eq. (1), and it has a ground space equiv-alent to the codespace of the code. In the case of thecolor codes it can be written as

H = −∑

p

(SXp + SZp

). (13)

The color-code Hamiltonian, like the surface-code Hamil-tonian, does not lead to a self-correcting quantum mem-ory, but we can use adiabatic interpolations betweenstatic Hamiltonians of the type in Eq. (13).

As in Sec. IV A, we can perform an adiabatic interpola-tion to initially create the color code without any defects.We imagine the same setting—a large number of qubitsin the ground state of local Hamiltonians H = −Z—andprepare the code by using an interpolation of the form

H(t) =

(1− t

T

)∑

j∈Q(−Zj) +

t

T

∑

p

(−SXp − SZp

)

+t

T

∑

j 6∈Q(−Zj) . (14)

(Since Z for the newly created code commutes with thisHamiltonian at all times, and since it initially has eigen-value +1, the qubit associated with the surface is pre-pared in the +1 eigenstate of Z. This is the gauge degreeof freedom mentioned above.) As we did for the surfacecode, we choose to create a small color code first and thengrow it to avoid a shrinking gap. The small color codeis grown in a manner similar to Sec. IV A. For example,to create a green Z-type defect in the +1 eigenstate ofZ, described for the surface code in Sec. IV B, two Z-type green plaquettes separated by one red plaquette areturned off while simultaneously turning on −XX on twopairs of qubits in between, as shown in Fig. 26. Note thatduring the defect’s creation a neighboring blue plaquettegets modified to a six-body operator and a neighboringred plaquette gets modified to a two-body operator.

The surface code procedures for growing and movingdefects, presented in Sec. IV C, can also be adapted to thecolor codes. We will not present the the cases for differentnumbers of interior qubits separately here. Rather, weexamine the simplest case when there are only two neigh-boring qubits. The other cases, as in the surface code,simply require more modifications of adjoining checks.To grow a Z-type green defect like the one in Fig. 26,first pick another green face. It will be separated fromthe defect region by a red plaquette. Along one of thetwo lines connecting the defect region to the green check,turn on −XX while turning off the green plaquette. Thiswill incur a modification a neighboring blue plaquette aswell as the red plaquette itself.

18

FIG. 26: Two adjacent green Z-plaquettes are turned off whileturning on the −XX Hamiltonian shown, creating a Z-typedefect in the +1 eigenstate of Z (shown here as a light bluestring encircling the defect). The green string depicts theassociated X operator.

Next, we show that the color code also supportsdetachment and attachment procedures, described inSec. IV D for the surface code. Imagine a two-plaquettered defect, depicted in Fig. 27, that we would like toisolate from the bulk code. To complete the detach-

FIG. 27: A Z-type red defect isolation procedure. The “draw-bridge” in this case is the red plaquette adjacent to the yel-low dots in the figure. The Z-type check on the red face isturned off while the two −XX operators are turned on. Thefour-body X operator that is the product of the two −XXHamiltonians is in the stabilizer group before the evolution,and it is trivially in the stabilizer group of the code after theevolution. The blue and green plaquettes adjacent to the yel-low dots are modified to be a four-body operators. (Also notethat the X-type check on the red plaquette must also turnedoff to fully isolate the region, and two −ZZ Hamiltonians areturned on.)

ment procedure for a Z-type red defect, two −XXHamiltonians—on the qubits indicated by yellow dots—are turned on while turning off the Z-type red plaquetteoperator adjacent to the dots. In the process, the adja-cent blue and green plaquettes get modified to four-bodyoperators. Since the four-body X operator that is the

product of the two −XX Hamiltonians is in the stabilizergroup at the beginning and at the end of the evolution,we have successfully severed the two code regions.

As discussed in Sec. IV E, it is important that we areable to prepare Z-type defects in eigenstates of X andvice versa. For color codes, the procedure is essentiallyidentical to the one for surface codes, and proceeds bypreparing single qubits in particular states (±1 eigen-states of X for Z-type defects and ±1 eigenstates of Zfor X-type defects). Just as before, a defect location isanticipated and the preparation of the surface proceedsnormally everywhere except for the defect.

Ancilla state injection for the color codes is slightlydifferent than the procedures for the surface code intro-duced in Sec. IV F. After isolating a region with greenboundaries, or creating such a region adjacent to a greenboundary, we use the procedures described above to in-troduce an X-type and a Z-type defect at the same lo-cation, as pictured in Fig. 28. Notice that the interior

FIG. 28: The creation of a defect region with both the X-typeand Z-type green checks turned off. There are four interiorqubits prepared in two Bell pairs by this procedure.

red checks have also been modified during this proce-dure, putting the four interior qubits into two Bell pairs.Additionally, the neighboring blue plaquettes have beenmodified to six-body operators. An evolution is thenperformed that only touches these four interior qubits,turning on the Hamiltonians pictured in Fig. 29 whileturning off the two −XX−ZZ Hamiltonians. Next, justas we did for the surface code, we adiabatically drag aqubit to the desired state, as pictured in Fig. 30. The“logical qubit” is localized to the upper-right qubit, withsingle-body X and Z operators. The next step is to“grow” these logical operators in a particular way. Thisis achieved by performing another adiabatic evolution on

19

FIG. 29: Four interior qubits are “exposed.”

FIG. 30: The upper-right qubit is adiabatically dragged to thedesired state. For instance, to inject T |+〉 states, U = TH.

the four qubits to the Hamiltonian represented in Fig. 31,which is just the reintroduction of the red face checksthat we turned off at the beginning. This evolution mod-ifies X and Z from single-body operators to the operatorsshown in Fig. 32. Finally, the X-type checks on the greenfaces currently housing the defect are turned on while theadjacent Z-type blue faces are turned off, leading to thesituation depicted in Fig. 33. As in the case of the surfacecode, one of these faces is moved away and absorbed into

FIG. 31: The single-body terms in Fig. 30 are turned offwhile turning on the X-type and Z-type checks on the redplaquette.

FIG. 32: X and Z after the reintroduction of the red plaquettein Fig. 31.

the green boundary of the region. Then the region is at-tached and the green defect encoding the state is movedinto the bulk computational region.

None of the other procedures introduced in Sec. IV andSec. V are appreciably different for the color codes. Mea-surements are still performed in an ancilla-coupled man-ner, and X and Z can still be applied in a heralded fash-ion. Logical CNOT gates are still performed by braiding,

20

with the control being a Z-type defect and the target be-ing an X-type defect. Ref. [64] discusses how to performa CNOT between defects of the same type (or color).Thus, all the ingredients are precisely the same, and en-coded universal quantum computation can be performedwith two ingredients: adiabatic interpolations betweenstatic Hamiltonians and ancilla-coupled measurements.

VIII. CONCLUSION

We have presented a model of quantum computa-tion that utilizes adiabatic interpolations between staticHamiltonians which encode quantum information in theirdegenerate ground spaces. By utilizing the process of adi-abatic code deformation, we create and grow small coderegions, introduce and braid defects, and inject arbitrarystates into defects. These procedures never cause theHamiltonian gap to shrink below a constant proportionalto ∆, and they can all be performed with the protec-tion of a gap and topology. However, to perform logicalmeasurements we use an ancilla-coupled scheme, braidingand isolating an ancilla defect and then turning pieces ofthe Hamiltonian off and destructively measuring a coderegion. Taken together, these procedures allow for uni-versal quantum computation.

Our model lives at the intersection of three other mod-els of quantum computation. It provides explicit exam-ples of adiabatic evolutions in the setting of a topologicalcode, and we make an effort to supply procedures that donot increase the rate at which errors (anyons) are intro-

FIG. 33: The arrangement of the defect after reintroducingthe X-type green plaquettes. X is a string of Pauli X oper-ators connecting two blue faces and Z is a loop of Pauli Zoperators around a blue face.

duced to the system. Since we store information in theground space of a changing Hamiltonian, our model alsoborrows intuition and robustness from holonomic quan-tum computing. Indeed, the braiding operations we per-form rely precisely on the non-trivial structure of groundspace holonomies. Lastly, our adiabatic interpolationsare like miniature adiabatic quantum computations, andtheir implementations are made less noisy by traversingan adiabatic path more slowly.

Unfortunately, the model we present is not fault-tolerant. While the lifetime of the ground space, andthus the encoded quantum information, is exponential in∆/T in the presence of coupling to a thermal bath, noprotection is gained by increasing the size of the code. Itwould be interesting to study a model that can activelyremove entropy from the system, utilizing active errorcorrection in a way that is compatible with the Hamil-tonian nature of the model, but we do not address theseproblems in this work.

We hope that the model we have analyzed here canbe useful for a further understanding of the properties ofquantum computation based on stabilizer Hamiltonians.In particular, it would be interesting to extend this workto models such as Kitaev’s quantum double model [4]or the Turaev-Viro codes [32], where universality can beachieved without the creation and distillation of magicstates.

Another line of inquiry worth investigating is thedegree to which the control requirements on our con-struction can be relaxed. In particular one can imaginemoving a defect not by turning off and on a few termsin a Hamiltonian to perform a deformation, but insteadby turning large numbers of these terms off and on atthe same time. This would have the advantage of notrequiring precise few-term control of a Hamiltonian, buta spatially more course-grained ability to change theHamiltonian. In [65] such an approach was investigatedfor adiabatic implementations of measurement-basedquantum computing, where it was argued that thisresults in a non-constant, but inverse-polynomial energygap. Such a gap would require a slower evolution tomaintain the adiabatic condition, and one might worrythat it would also destroy the robustness of the mode.However [65] argued that this polynomial gap did notdestroy the error protection properties in a worse man-ner than the constant gap model. Can the topologicaladiabatic evolutions we describe here be done similarly,with the ability to only change the Hamiltonian over aspatial course graining?

Addendum: In the course of writing this manuscript,Zheng and Brun in Ref. [66] published an article on asimilar topic; it is worth comparing and contrasting ourwork to theirs.

Both works bring together concepts from holonomic,adiabatic, and circuit-model quantum computing toeffect universal quantum computation. Both worksalso utilize adiabatic interpolations between degenerate

21

Hamiltonians in a way that maintains a constant energygap.

Our work differs in that we expand in detail about howadding the extra ingredient of topological codes into themix offers additional modes of error suppression and lo-cal quantum processing. We develop explicit methods forhow adiabatic, holonomic, and circuit-model ideas can bebrought to bear on topological codes, leading to a com-prehensive model of “adiabatic topological quantum com-puting.” The work by Zheng and Brun concludes withthe sentences “We hope to apply our method to fault-tolerant schemes based on large block codes and topolog-ical codes, which may have higher thresholds than fault-tolerant schemes that concatenate small codes. Verylikely, the maximum weight of the Hamiltonian termsused to describe topological codes during adiabatic evo-lution will be small and well bounded.”

Our work also differs in that we focus on a model ofquantum computation that only uses (a) adiabatic inter-polations between Hamiltonians that can never be com-pletely turned off and (b) measurements of logical oper-ators; we further we make it clear that these operationsalone are insufficient to make our model fault-tolerant rel-ative to standard definitions of fault-tolerance. The workby Zheng and Brun focuses on a model that has theseoperations but also adds (c) the ability to measure codecheck operators and (d) the ability to completely turnon and off Hamiltonians. With these additional features,their model becomes fault tolerant according to a defi-nition of fault-tolerance they provide. Augmented withthese capabilities, our model also becomes fault-tolerantaccording to their definition, but we have not highlightedthis property in the main text as our emphasis is on thefeatures of pure adiabatic topological quantum comput-ing model.

Finally, by explicitly going through the steps of howto implement each element of a universal set of encoded

operations, we have found that contrary to the state-ment in the work of Zheng and Brun that “standardtechniques, like magic state injection and distillation, canrealize fault-tolerant encoded non-Clifford gates,” it canin fact be quite subtle as to how to realize state injec-tion by adiabatic interpolations. Indeed, we point outthat there are even qualitative differences between howto do this correctly for surface codes and for color codes.Repeating the end of our main Conclusion section above,this revelation suggests that an interesting area for futureresearch would be extending our analysis to models thatcan achieve universality without the need for the creationand distillation of magic states.

Acknowledgments

CC and AJL were supported in part by NSF grant0829944. CC and AJL were supported in part by theLaboratory Directed Research and Development programat Sandia National Laboratories. Sandia National Lab-oratories is a multi-program laboratory managed andoperated by Sandia Corporation, a wholly owned sub-sidiary of Lockheed Martin Corporation, for the U.S.Department of Energy’s National Nuclear Security Ad-ministration under contract DE-AC04-94AL85000. DBand AN were supported in part by NSF grants 0621621,0803478, 0829937, and 091640. DB was supported inpart by the DARPA/MTO QuEST program throughgrant FA9550-09-1-0044 from AFOSR. STF was sup-ported by the IARPA MQCO program, by the US ArmyResearch Office grant numbers W911NF-14-1-0098 andW911NF-14-1-0103, by the ARC via EQuS project num-ber CE11001013, and by an ARC Future FellowshipFT130101744.

[1] P. W. Shor, Scheme for reducing decoherence in quan-tum computer memory, Phys. Rev. A 52, R2493 (1995),doi:10.1103/PhysRevA.52.R2493.

[2] A. M. Steane, Error correcting codes in quan-tum theory, Phys. Rev. Lett. 77, 793 (1996),doi:10.1103/PhysRevLett.77.793.

[3] J. Preskill, Fault-tolerant quantum computation, inIntroduction to Quantum Computation and Informa-tion, edited by H.-K. Lo, T. Spiller, and S. Popescu(World Scientific, Singapore / River Edge, NJ,1998), chap. 8, pp. 213–269, ISBN 9-810-24410-X,arXiv:quant-ph/9712048.

[4] A. Y. Kitaev, Fault-tolerant quantum com-putation by anyons, Ann. Phys. 303, 2(2003), doi:10.1016/S0003-4916(02)00018-0,arXiv:quant-ph/9707021.

[5] E. Farhi, J. Goldstone, S. Gutmann, and M. Sipser,Quantum computation by adiabatic evolution (2000),arXiv:quant-ph/0001106.

[6] O. Oreshkov, T. A. Brun, and D. A. Lidar, Fault-tolerantholonomic quantum computation, Phys. Rev. Lett. 102,070502 (2009), doi:10.1103/PhysRevLett.102.070502,arXiv:0806.0875.

[7] D. Bacon and S. T. Flammia, Adiabatic gateteleportation, Phys. Rev. Lett. 103, 120504(2009), doi:10.1103/PhysRevLett.103.120504,arXiv:0905.0901.

[8] E. Dennis, A. Kitaev, A. Landahl, and J. Preskill, Topo-logical quantum memory, J. Math. Phys. 43, 4452 (2002),doi:10.1063/1.1499754, arXiv:quant-ph/0110143.

[9] R. Raussendorf, J. Harrington, and K. Goyal, Afault-tolerant one-way quantum computer, Ann. Phys.321, 2242 (2006), doi:10.1016/j.aop.2006.01.012,arXiv:quant-ph/0510135.

[10] H. Bombin and M. Martin-Delgado, Quan-tum measurements and gates by code defor-mation, J. Phys. A: Math. Theor. 42, 095302(2009), doi:10.1088/1751-8113/42/9/095001,

22

arXiv:0704.2540.[11] A. G. Fowler, A. M. Stephens, and P. Groszkowski,

High-threshold universal quantum computation on thesurface code, Phys. Rev. A 80, 052312 (2009),doi:10.1103/PhysRevA.80.052312, arXiv:0803.0272.

[12] H. Bombin, Clifford gates by code deforma-tion, New Journal of Physics 13, 043005(2011), doi:10.1088/1367-2630/13/4/043005,arXiv:1006.5260.

[13] C. Horsman, A. G. Fowler, S. Devitt, andR. Van Meter, Surface code quantum comput-ing by lattice surgery, New J. Phys. 14, 123011(2012), doi:10.1088/1367-2630/14/12/123011,arXiv:1111.4022.

[14] P. Bonderson, Measurement-only topological quantumcomputation via tunable interactions, Phys. Rev. B87, 035113 (2013), doi:10.1103/PhysRevB.87.035113,arXiv:1210.7929.

[15] C. Nayak, S. H. Simon, A. Stern, M. Freedman, andS. D. Sarma, Non-Abelian anyons and topological quan-tum computation, Rev. Mod. Phys. 80, 1083 (2008),doi:10.1103/RevModPhys.80.1083, arXiv:0707.1889.

[16] V. Lahtinen and J. K. Pachos, Non-Abelian statistics as aBerry phase in exactly solvable models, New J. Phys. 11,093027 (2009), doi:10.1088/1367-2630/11/9/093027,arXiv:0901.3674.

[17] S. Bravyi, M. Hastings, and S. Michalakis, Topo-logical quantum order: stability under local per-turbations, J. Math. Phys. 51, 093512 (2010),doi:10.1063/1.3490195, arXiv:1001.0344.

[18] R. Alicki, M. Fannes, and M. Horodecki, Onthermalization in Kitaev’s 2D model, J. Phys.A: Math. Theo. 42, 065303 (2009), ISSN 1751-8113, doi:10.1088/1751-8113/42/6/065303,arXiv:0810.4584.

[19] D. Bacon, Operator quantum error-correcting subsys-tems for self-correcting quantum memories, Phys. Rev. A73, 012340 (2006), doi:10.1103/PhysRevA.73.012340,arXiv:quant-ph/0506023v4.

[20] M. H. Freedman, A magnetic model with a pos-sible Chern-Simons phase (with an appendix by F.Goodman and H. Wenzl), Comm. Math. Phys.234, 129 (2003), doi:10.1007/s00220-002-0785-1,arXiv:quant-ph/0110060.

[21] M. Freedman, C. Nayak, and K. Shtengel, Ex-tended Hubbard model with ring exchange: Aroute to non-Abelian topological phase, Phys.Rev. Lett. 94, 066401 (2005), e-print differs sig-nificantly, doi:10.1103/PhysRevLett.94.066401,arXiv:cond-mat/0309120.

[22] J. Brink and Z. Wang, On Freedman’s latticemodels for topological phases, Quant. Inf. Proc.2, 81 (2003), doi:10.1023/A:1025883100137,arXiv:math-ph/0303018.

[23] A. Kitaev, Anyons in an exactly solvedmodel and beyond, Ann. Phys. 321, 2(2006), doi:10.1016/j.aop.2005.10.005,arXiv:cond-mat/0506438.

[24] M. Freedman, C. Nayak, and K. Walker, Towardsuniversal topological quantum computation in the ν =(5/2) fractional quantum Hall state, Phys. Rev. B73, 245307 (2006), doi:10.1103/PhysRevB.73.245307,arXiv:cond-mat/0512066.

[25] J. P. Barnes and W. S. Warren, Automatic

quantum error correction, Phys. Rev. Lett. 85,856 (2000), doi:10.1103/PhysRevLett.85.856,arXiv:quant-ph/9912104.

[26] D. Bacon, K. R. Brown, and K. B. Whaley,Coherence-preserving quantum bits, Phys. Rev. Lett. 87,247902 (2001), doi:10.1103/PhysRevLett.87.247902,arXiv:quant-ph/0012018.

[27] Y. S. Weinstein and C. S. Hellberg, Ener-getic suppression of decoherence in exchange-only quantum computation, Phys. Rev. A 72,022319 (2005), doi:10.1103/PhysRevA.72.022319,arXiv:quant-ph/0408037.

[28] D. Bacon, Stability of quantum concatenated codeHamiltonians, Phys. Rev. A 78, 042324 (2008),doi:10.1103/PhysRevA.78.042324, arXiv:0806.2160.

[29] F. Wilczek, Quantum mechanics of fractional-spin particles, Phys. Rev. Lett. 49, 957 (1982),doi:10.1103/PhysRevLett.49.957.

[30] M. H. Freedman, A. Kitaev, and Z. Wang,Simulation of topological field theories by quan-tum computers, Comm. Math. Phys. 227,587 (2002), doi:10.1007/s002200200635,arXiv:quant-ph/0001071.

[31] M. H. Freedman, M. Larsen, and Z. Wang,A modular functor which is universal forquantum computation, Comm. Math. Phys.227, 605 (2002), doi:10.1007/s002200200645,arXiv:quant-ph/0001108.

[32] R. Koenig, G. Kuperberg, and B. W. Reichardt, Quan-tum computation with Turaev-Viro codes, Ann. Phys.325, 2707 (2010), doi:10.1016/j.aop.2010.08.001,arXiv:1002.2816.

[33] R. Konig, Composite anyon coding and the initializa-tion of a topological quantum computer, Phys. Rev. A81, 052309 (2010), doi:10.1103/PhysRevA.81.052309,arXiv:0910.2427.

[34] P. Bonderson, M. Freedman, and C. Nayak,Measurement-only topological quantum com-putation, Phys. Rev. Lett. 101, 010501(2008), doi:10.1103/PhysRevLett.101.010501,arXiv:0802.0279.

[35] P. Bonderson, M. Freedman, and C. Nayak,Measurement-only topological quantum computationvia anyonic interferometry, Ann. Phys. 324, 787 (2009),doi:10.1016/j.aop.2008.09.009, arXiv:0808.1933.

[36] R. Raussendorf, J. Harrington, and K. Goyal,Topological fault-tolerance in cluster statequantum computation, New J. Phys. 9, 199(2007), doi:10.1088/1367-2630/9/6/199,arXiv:quant-ph/0703143.

[37] S. B. Bravyi and A. Y. Kitaev, Quantum codes on a lat-tice with boundary (1998), arXiv:quant-ph/9810052.

[38] P. Zanardi and M. Rasetti, Holonomic quan-tum computation, Phys. Lett. A 264, 94(1999), doi:10.1016/S0375-9601(99)00803-8,arXiv:quant-ph/9904011.

[39] D. Kult, J. Aberg, and E. Sjoqvist, Noncyclic ge-ometric changes of quantum states, Phys. Rev. A74, 022106 (2006), doi:10.1103/PhysRevA.74.022106,arXiv:quant-ph/0512045.

[40] O. Oreshkov, Holonomic quantum computationin subsystems, Phys. Rev. Lett. 103, 090502(2009), doi:10.1103/PhysRevLett.103.090502,arXiv:0905.1249.

23

[41] D. Bacon and S. T. Flammia, Adiabatic cluster-statequantum computing, Phys. Rev. A 82, 030303(R) (2010),doi:10.1103/PhysRevA.82.030303, arXiv:0912.2098.

[42] R. Raussendorf and H. J. Briegel, A one-way quan-tum computer, Phys. Rev. Lett. 86, 5188 (2001),doi:10.1103/PhysRevLett.86.5188.

[43] J. M. Renes, A. Miyake, G. K. Brennen, andS. D. Bartlett, Holonomic quantum comput-ing in symmetry-protected ground states of spinchains, New Journal of Physics 15, 025020(2013), doi:10.1088/1367-2630/15/2/025020,arXiv:1103.5076.

[44] E. Farhi, J. Goldstone, S. Gutmann, J. La-pan, A. Lundgren, and D. Preda, A quan-tum adiabatic evolution applied to random in-stances of an NP-complete problem, Science292, 472 (2001), doi:10.1126/science.1057726,arXiv:quant-ph/0104129.

[45] D. Aharonov, W. van Dam, J. Kempe, Z. Landau,S. Lloyd, and O. Regev, Adiabatic quantum computationis equivalent to standard quantum computation, in Pro-ceedings of the 45th IEEE Symposium on Foundations ofComput Science, edited by D. Azada, IEEE (IEEE Press,Los Alamitos, CA, Oct. 17–19, Rome, IT, 2004), pp.42–51, ISBN 0-7695-2228-9, doi:10.1109/FOCS.2004.8,arXiv:quant-ph/0405098.

[46] R. Oliveira and B. M. Terhal, The complexity of quantumspin systems on a two-dimensional square lattice, Quant.Inf. Comp. 8, 0900 (2008), arXiv:quant-ph/0504050,URL http://www.rintonpress.com/xxqic8/qic-8-10/

0900-0924.pdf.[47] A. Mizel, D. A. Lidar, and M. Mitchell, Simple

proof of equivalence between adiabatic quantum com-putation and the circuit model, Phys. Rev. Lett. 99,070502 (2007), doi:10.1103/PhysRevLett.99.070502,arXiv:quant-ph/0609067.

[48] J. Kempe, A. Kitaev, and O. Regev, The complex-ity of the local Hamiltonian problem, SIAM J. Comp.35, 1070 (2006), doi:10.1137/S0097539704445226,arXiv:quant-ph/0406180.

[49] S. Bravyi and A. Kitaev, Universal quantum computationwith ideal Clifford gates and noisy ancillas, Phys. Rev. A71, 022316 (2005), doi:10.1103/PhysRevA.71.022316,arXiv:quant-ph/0403025.

[50] H. Bombin and M. A. Martin-Delgado, Topolog-ical quantum distillation, Phys. Rev. Lett. 97,180501 (2006), doi:10.1103/PhysRevLett.97.180501,arXiv:quant-ph/0605138.

[51] D. Gottesman, Stabilizer codes and quantum er-ror correction, Ph.D. thesis, Caltech (1997),arXiv:quant-ph/9705052.

[52] F. J. MacWilliams and N. J. A. Sloane, The Theory ofError-Correcting Codes, vol. 16 of North-Holland mathe-matical library (North-Holland, New York, 1977), ISBN0-444-85009-0.

[53] A. Hamma and D. A. Lidar, Adiabatic prepara-tion of topological order, Phys. Rev. Lett. 100,

030502 (2008), doi:10.1103/PhysRevLett.100.030502,arXiv:quant-ph/0607145.

[54] M. de Wild Propitius and F. A. Bais, Discrete gaugetheories, in Particles and Fields ’94 CRM-CAP SummerSchool (1994), arXiv:hep-th/9511201.

[55] A. Hamma, R. Ionicioiu, and P. Zanardi, Bi-partite entanglement and entropic boundarylaw in lattice spin systems, Phys. Rev. A 71,022315 (2005), doi:10.1103/PhysRevA.71.022315,arXiv:quant-ph/0409073.

[56] A. Kitaev and J. Preskill, Topological entan-glement entropy, Phys. Rev. Lett. 96, 110404(2006), doi:10.1103/PhysRevLett.96.110404,arXiv:hep-th/0510092.

[57] M. Levin and X.-G. Wen, Detecting topological orderin a ground state wave function, Phys. Rev. Lett. 96,110405 (2006), doi:10.1103/PhysRevLett.96.110405,arXiv:cond-mat/0510613.

[58] S. T. Flammia, A. Hamma, T. L. Hughes, and X.-G.Wen, Topological entanglement Renyi entropy and re-duced density matrix structure, Phys. Rev. Lett. 103,261601 (2009), doi:10.1103/PhysRevLett.103.261601,arXiv:0909.3305.

[59] S. Bravyi and B. Terhal, A no-go theorem fora two-dimensional self-correcting quantum mem-ory based on stabilizer codes, New J. Phys. 11,043029 (2009), doi:10.1088/1367-2630/11/4/043029,arXiv:0810.1983.

[60] R. Raussendorf and J. Harrington, Fault-tolerantquantum computation with high threshold intwo dimensions, Phys. Rev. Lett. 98, 190504(2007), doi:10.1103/PhysRevLett.98.190504,arXiv:quant-ph/0610082.

[61] A. Steane, Multiple particle interference and quantumerror correction, Proc. Roy. Soc. London A 452, 2551(1996), arXiv:quant-ph/9601029, URL http://www.

jstor.org/stable/52827.[62] D. Gottesman, The Heisenberg representation of quan-

tum computers, in Group22: Proceedings of the XXIIInternational Colloquium on Group Theoretical Meth-ods in Physics, edited by S. P. Corney, R. Delbourgo,and P. D. Jarvis (International Press, Cambridge, MA,13–17 Jul. 1998, Hobart, Australia, 1999), pp. 32–43,arXiv:quant-ph/9807006.

[63] J. T. Anderson, Homological stabilizer codes (2011),arXiv:1107.2502.

[64] A. J. Landahl, J. T. Anderson, and P. R. Rice, Fault-tolerant quantum computing with color codes (2011),arXiv:1108.5738.

[65] D. Bacon, S. T. Flammia, and G. M. Crosswhite, Adia-batic quantum transistors, Phys. Rev. X 3, 021015 (2013),doi:10.1103/PhysRevX.3.021015, arXiv:1207.2769.

[66] Y.-C. Zheng and T. A. Brun, Fault-tolerant scheme ofholonomic quantum computation on stabilizer codes withrobustness to low-weight thermal noise, Phys. Rev. A89, 032317 (2014), doi:10.1103/PhysRevA.89.032317,arXiv:1309.1534.