A no-go theorem for a two-dimensional self-correcting quantum memory based on stabilizer codes

We study properties of stabilizer codes that permit a local description on a regular D-dimensional lattice. Specifically, we assume that the stabilizer group of a code (the gauge group for subsystem codes) can be generated by local Pauli operators such that the support of any generator is bounded by a hypercube of constant size. Our first result concerns the optimal scaling of the distance $d$ with the linear size of the lattice $L$. We prove an upper bound $d=O(L^{D-1})$ which is tight for D=1,2. This bound applies to both subspace and subsystem stabilizer codes. Secondly, we analyze the suitability of stabilizer codes for building a self-correcting quantum memory. Any stabilizer code with geometrically local generators can be naturally transformed to a local Hamiltonian penalizing states that violate the stabilizer condition. A degenerate ground-state of this Hamiltonian corresponds to the logical subspace of the code. We prove that for D=1,2 the height of the energy barrier separating different logical states is upper bounded by a constant independent of the lattice size L. The same result holds if there are unused logical qubits that are treated as"gauge qubits". It demonstrates that a self-correcting quantum memory cannot be built using stabilizer codes in dimensions D=1,2. This result is in sharp contrast with the existence of a classical self-correcting memory in the form of a two-dimensional ferromagnet. Our results leave open the possibility for a self-correcting quantum memory based on 2D subsystem codes or on 3D subspace or subsystem codes.


I. INTRODUCTION
One of the most intriguing open problems in the field of quantum information processing is whether one can build a self-correcting quantum memory -a macroscopic physical system storing quantum information for macroscopic periods of time without active error correction [1].If it exists, such a hypothetical device could play the role of a "quantum hard drive" in a future quantum computing technology.It is also a question of fundamental interest how to design a system which allows for quantum coherence to be preserved at non-zero temperature, similar in some sense to the quest to understand the origin of high-temperature superconductivity.
A possible scenario of how quantum self-correction can be achieved in realistic physical systems was proposed by Kitaev [2].The main idea of [2] was to mimic selfcorrection in classical magnetic media storage devices using quantum spin or electron Hamiltonians with topologically ordered ground-states.Logical qubits encoded into the ground-state of such Hamiltonian become virtually isolated from the environment assuming that the environment can only probe the system locally by applying small static perturbations to the Hamiltonian.Note that what is usually called a topological order translates to coding language as simply the condition for a quantum code to have a macroscopic distance.A number of generalizations and proposals how this scenario could be imple-mented in the lab have been made recently [3,4,5,6,7].
As was first explicitly noted in [8], if the system interacts with a thermal bath, the presence of a topological order in the ground-state by itself does not guarantee self-correction.Indeed, one may expect that local errors created by thermal fluctuations will tend to accumulate which may result in a global error having a non-trivial effect on the encoded qubits.This phenomenon of 'thermal fragility' of a topological order was studied by Nussinov and Ortiz in [9].For Kitaev's 2D toric code the loss of topological order at any non-zero temperature was studied in [9,10,11,12].
The main challenge in constructing a self-correcting memory is to combine the existence of a coding groundspace with a natural, passive, energy dissipation mechanism which prevents errors from accumulating.It was argued by Dennis et al. [8] that the 4D version of the toric code introduced by Kitaev in [2] is indeed a selfcorrecting quantum memory.In [1] Bacon considered the question of a self-correcting memory in dimensions less than 4.He introduced a three-dimensional model, based on a subsystem code which is now called the threedimensional Bacon-Shor code, which could be a model of self-correcting quantum memory.
In order to set the stage for our results on a possible self-correcting quantum memory, it is instructive to review the classical state of affairs.A classical 1D Ising ferromagnet has two degenerate ground-states corresponding to the classical repetition code.The distance of this code is n, the number of spins.A classical 1D ferromagnet is not a classical self-correcting memory, since the phase transition to a disordered phase occurs at zero temperature.The intuitive reason is that the energy cost of a single domain of flipped spins is independent of the size of the domain and hence such domain can grow without cost destroying the order.A 2D classical Ising ferromagnet is a self-correcting memory; the model exhibits a low-temperature memory phase separated by a phase transition to a disordered phase [24].
The 1D and 2D Ising ferromagnets allow for storage of only classical information, since the distance of the classical repetition code with respect to phase-flip errors is 1.Guided by this example, one can take the following conditions as necessary for a classical spin system to be a self-correcting memory: 1.The system has a degenerate ground-state; one has to flip a macroscopic number of spins in order to map one ground-state to another.
2. A macroscopic energy barrier has to be traversed by any sequence of single-spin flips mapping one ground-state to another.
Note that if condition 1 is violated, the environment can destroy the encoded information by acting only on a few spins.If condition 2 is violated, there is no reason to expect that an energy dissipation mechanism will prevent single-spin errors from accumulating into a logical error.For example, the 1D Ising model satisfies condition 1 but fails to satisfy condition 2. On the other hand, the 2D Ising model satisfies both conditions since mapping one ground-state (all spins up) to the other (all spins down) requires creating a domain wall of macroscopic size.
Let us now consider a system made up from n quantum spins (qubits) with a degenerate ground-state spanning a linear subspace L ⊆ (C 2 ) ⊗n which will be used to encode logical qubits [25].The subspace L can be viewed as the logical subspace of a quantum code.
In the present paper we shall restrict ourselves to stabilizer codes (a.k.a.additive codes).The main idea of stabilizer codes is to encode k logical qubits into n physical qubits using a logical subspace L ⊆ (C 2 ) ⊗n spanned by states |ψ that are invariant under the action of a stabilizer group S, Here S may be an arbitrary Abelian subgroup of the Pauli group For any stabilizer group S one can always choose a set of generators S = S 1 , . . ., S m such that S a ∈ P are self-adjoint Pauli operators.Thus the logical subspace L can be regarded as the ground-space of a Hamiltonian [26] Note that all terms in H pairwise commute.In addition, the Hamiltonian has a constant gap above the groundspace.All eigenvalues and eigenvectors of H can be explicitly computed using the stabilizer formalism [13].If all generators are independent, one has m = n − k.In general m > n−k since it may be advantageous to choose an over-complete set of generators in order to make the energy barrier higher.We will assume that the physical qubits live at vertices of a D-dimensional lattice Λ = {1, . . ., L} D with open or periodic boundary conditions.This choice for regular D-dimensional lattice is made for pedagogical reasons, since all our results can be generalized straightforwardly to an arbitrary graph embedded into a D-dimensional space.Accordingly, there are n = L D physical qubits.We would like the quantum memory Hamiltonian defined in Eq. ( 1) to be physically realizable, thus we demand that it involves only short-range interactions.More precisely, we assume that the support of every generator S a can be bounded by a hypercube with r D vertices for some constant interaction range r.
Recall that the weight |P | of a Pauli operator P = P 1 . . .P n ∈ P is the number of non-identity single-qubit Pauli operators P i .The distance d of a stabilizer code is the minimum weight of an undetectable Pauli error, i.e., an operator P ∈ P preserving the logical subspace L and inducing a non-trivial transformation on L, Here C(S) is the centralizer of the subgroup S, i.e., a group of Pauli operators commuting with every element of S. The notation C(S)\S means a subset of elements in C(S) which are not in S.
Let the system described by Hamiltonian Eq. ( 1) interact with a thermal bath.In order to decide whether the system is a good quantum memory, one in principle would have to choose a dynamical model describing the interaction with a thermal bath, then choose a particular decoding algorithm and calculate how the probability of failure at the decoding step scales with the system size.For realistic dynamical models such as Davies' weak coupling limit [18,19], pursuing this approach seems to be completely hopeless.However, it is not unreasonable to assume that the bath dephases the system on short timescales T 2 ≪ T 1 [27].Hence, after a short dephasing time, the state of the system is a mixture of energy eigenstates and the effect of the bath is a process of energy exchange with the system.The state of the system can thus be represented as a probabilistic mixture of energy eigenstates E |ψ , where |ψ ∈ L is the encoded logical state and E ∈ P is a Pauli error.An error E ∈ P destroys encoded information if it is undetectable by the code L, i.e., if the restriction of E onto L induces a non-trivial transformation on L. Under these assumptions we can now state the quantum analogue of conditions 1,2 which are necessary for a quantum spin system to be a self-correcting quantum memory: 1q.The ground-space of a (Hamiltonian) system is the logical subspace of a quantum error correcting code with macroscopic distance.
2q.A macroscopic energy barrier has to be traversed by any sequence of single-qubit Pauli errors resulting in an undetectable error.
The question that we address in this paper is: what quantum error correcting codes are compatible with conditions 1q and 2q?Note again that our conditions are necessary conditions for a self-correcting quantum memory; we do not claim that they are also sufficient conditions.In particular, whether a model is a self-correcting quantum memory may depend on details of the scaling of entropy versus energy at non-zero temperature.

A. Bounds on The Distance
Our first result concerns the optimal scaling of the distance d with the linear size of the lattice L. It allows one to check whether a code is compatible with condition 1q.In Section II we prove the following theorem Theorem 1.Let S = S 1 , . . ., S m be a stabilizer code on a D-dimensional lattice Λ = {1, . . ., L} D .Suppose the support of any generator S a can be bounded by a hypercube with r D vertices.Then the distance of S satisfies (2)

This bound holds for both periodic and open boundary conditions.
This theorem implies that any stabilizer code on a 1D lattice fails to satisfy condition 1q.It contrasts the fact that for classical 1D codes the distance can be of order L (consider as an example the 1D repetition code).For a 2D lattice the bound Eq. ( 2) allows d to grow linearly with L which is compatible with condition 1q.Surface codes [14] provide an example of 2D codes for which the bound Eq. ( 2) is saturated.
We are not aware of any codes saturating the bound Eq. (2) for D ≥ 3. Note that a generalized toric code on a D-dimensional lattice [28] has distance d ∼ L ⌊D/2⌋ .We conjecture that in D = 3 the distance of any stabilizer code with local generators satisfies d = O(L).
If a stabilizer code has more than one logical qubit, some of the logical qubits may be protected from the environment better than the others.Note that Theorem 1 bounds the minimum weight of logical operators for the worst choice of a logical qubit.One can ask whether the same bound applies to the best logical qubit as well.
To state this question more formally assume that we encode k qubits using a stabilizer code S with g + k logical qubits for some g > 0. We will regard the extra g logical qubits with the corresponding logical Pauli operators X 1 , Z 1 , . . ., X g , Z g as unused "gauge qubits" [20] such that any error affecting only the gauge qubits can be ignored.At the same time we can use the logical Pauli operators on the gauge qubits to minimize the weight of 'useful' logical operators.Thus, in this case the relevant distance would be the minimum weight of a Pauli operator P preserving the logical subspace, i.e., P ∈ C(S), that cannot be generated by stabilizers and logical Pauli operators on the gauge qubits, that is, In Section III C we will use the formalism of subsystem codes to prove the following extension of Theorem 1.
Theorem 1 * .Under the assumptions of Theorem 1 the distance d(G) satisfies the bound Eq. ( 2) for any choice of logical operators X 1 , Z 1 , . . ., X g , Z g on the gauge qubits.
Let us remark that an analogous bound does not apply to 'bare' logical operators, i.e., P ∈ C(G)\G.The minimal weight of 'bare' logical operators can be of order L D , see [29].

B. Bounds on The Energy Barrier
Our second result concerns the scaling of the energy barrier with lattice size L. In contrast to the distance d the energy barrier is not a property of the stabilizer group S only -it depends on the choice of generators S a used to define the Hamiltonian Eq. (1).As was mentioned above, the set of generators can be vastly overcomplete (consider as an example the 4D toric code).In order to exclude overcomplete generating sets in which some generator S a appears a macroscopic number of times we shall impose a (natural) restriction that any qubit can participate only in a constant number of generators S a .
Note that the Hamiltonian Eq. ( 1) has a ground-state energy −m.Let |ψ ∈ L be any ground-state and E ∈ P be any Pauli operator.Since E either commutes or anticommutes with every term in the Hamiltonian, a state E |ψ has energy ψ|E † HE|ψ = −m + ǫ(E), where ǫ(E) is proportional to the number of Pauli operators S a in the Hamiltonian H which anticommute with E, We shall refer to ǫ(E) as the energy cost of a Pauli operator E.
Let us say that a sequence P 0 , P 1 , . . ., P t ∈ P is a walk on the Pauli group starting at P 0 and arriving at P t iff for all i the operators P i and P i+1 differ by at most one qubit.Let W(S, T ) be a set of all walks starting at S and arriving at T .For any walk γ ∈ W(S, T ) let ǫ max (γ) be the maximum energy reached by γ ǫ max (γ) = max Suppose the environment tries to implement a Pauli error E ∈ P by a sequence of single-qubit Pauli errors.The minimum amount of energy the environment has to inject into the system in order to implement E is Thus the energy barrier the environment has to overcome in order to implement a non-trivial logical operator on the encoded qubits is Let us emphasize once more that in contrast to the distance d the energy barrier d ‡ is not uniquely determined by the stabilizer group S but is a function of the generating set S 1 , . . ., S m used to construct the Hamiltonian Eq. ( 1).Note that our assumption that the environment implements a logical operator by single-qubit Pauli errors is not a restriction if we are interested in determining the scaling of the energy barrier d ‡ with L. To see this, imagine that the environment instead makes Pauli errors with weight at most w = O(1) at the time.One can always simulate a single step of such a walk by w steps with single-qubit Pauli errors.It can increase the maximum energy reached by any walk by at most a constant and hence the energy barrier d ‡ can change at most by a constant.
Using the assumption that any qubit participates in O( 1) generators S a one can easily prove a naive upper bound Therefore, if we want d ‡ to grow with L we must look for codes with the distance d growing with L. For 2D codes one may have d ∼ L and thus the naive upper bound Eq. ( 6) cannot rule out a possibility that d ‡ grows with L. In Section II we prove the following theorem: Theorem 2. Let S = S 1 , . . ., S m be a stabilizer code with local generators on a 2D lattice such that each qubit participates in a constant number of generators.Then the energy barrier d ‡ is upper bounded by a constant independent of the lattice size L.
This theorem tells us that 2D stabilizer codes cannot be compatible with condition 2q and thus the corresponding Hamiltonians defined in Eq. ( 1) cannot be a self-correcting quantum memory.This result contrasts the fact that 2D classical codes with local generators (e.g. the 2D Ising model) can be used to build a self-correcting classical memory.We remark that Theorem 2 applies to both open and periodic boundary conditions.It can also be easily generalized to quasi-2D lattices with the number of 2D layers bounded by a constant independent of L.
Theorem 2 can be strengthened for stabilizer codes which encode more than one logical qubit.Specifically, we can encode k qubits using a stabilizer code with g + k logical qubits by regarding the extra g logical qubits as "gauge qubits", see the discussion after Theorem 1. Accordingly, any error affecting only the gauge qubits can be ignored.In this case the energy barrier that the environment has to overcome in order to implement a non-trivial logical operator would be where G = S, X 1 , Z 1 , . . ., X g , Z g is a group generated by S and the logical Pauli operators on the gauge qubits.
In Section III C we will use the formalism of subsystem codes to prove the following extension of Theorem 2.
Theorem 2 * .Under the assumptions of Theorem 2 the energy barrier d ‡ (G) is upper bounded by a constant independent of the lattice size L for any choice of the gauge Pauli operators X 1 , Z 1 , . . ., X g , Z g .
It has been observed by many authors [1,19] that the 2D toric code does not feature a macroscopic energy barrier since the logical operators for this code have a stringlike geometry.The energy cost of a partially implemented logical operator comes only from the two end-points of a string which cannot be larger than some small constant.One can ask whether logical operators for general 2D stabilizer codes can always be chosen as "strings" (in which case the logical operators can be interpreted as moving point-like anyons around the lattice).The proof of Theorem 2 presented in Section II provides a partial answer to this question.It implies that for any 2D stabilizer code with generators of size r × r there exists at least one logical operator whose support can be covered by a rectangle of size r × L. Such a rectangle can be regarded as a quasi-1D string.

C. Beyond Subspace Stabilizer Codes
Hamiltonians of the form in Eq. ( 1) may seem like overly restrictive models to consider for a quantum memory, in particular since they involve a set of commuting operators.Common models in many-body physics involve geometrically-local sets of non-commuting operators, such as the Heisenberg model and its variants, Kitaev's honeycomb model [4], the quantum compass model, see e.g.[21], etc.Such Hamiltonians can always be written as where r a are real coefficients and G a are elements of the Pauli group P with local support.The formalism of stabilizer subsystem codes [20] provides a systematic way of constructing Hamiltonians of the form Eq. ( 8) with a degenerate ground-state that can be taken as possible models of a quantum memory.This formalism focuses on those symmetries of the Hamiltonian that can be described using the Pauli group ignoring all other non-Pauli symmetries such as the SU (2)-symmetry (since they cannot be analyzed using the framework of stabilizer codes).By analogy with stabilizer codes which can be fully characterized by the stabilizer group, a subsystem code can be characterized by its gauge group.In our case the gauge group G is the group generated by the Pauli operators G a , see Eq. ( 8).Conversely, any (non-abelian) subgroup G ⊆ P with local generators G 1 , . . ., G m yields a family of Hamiltonians Eq. ( 8).The symmetries of the Hamiltonian H defined in Eq. ( 8) are described by the centralizer of G, i.e. those elements in P which commute with every element in G.It can be always represented as where S is the center of the gauge group, i.e. S = G ∩ C(G), and X j , Z j are logical Pauli operators of the quantum code.Since the symmetries of H include the logical Pauli group on the k logical qubits, any eigenvalue of H has degeneracy at least 2 k .In particular, the ground-state of H can be used to encode k logical qubits.
The group S is called a stabilizer group of the subsystem code.It induces a decomposition of the Hilbert space of n qubits into G-invariant sectors, (C 2 ) ⊗n = s L s , where s labels different syndromes, i.e., irreps of the stabilizer group.Given any syndrome s, the corresponding sector L ≡ L s defines a logical subspace of the subsystem code [30].The logical subspace possesses a subsystem structure, L = L logical ⊗ L gauge , where L logical defines the logical subsystem and L gauge defines the gauge subsystem.The gauge group G restricted to L can be identified with the group of Pauli operators on the gauge subsystem L gauge .The group generated by the logical operators X j , Z j restricted to L can be identified with the group of Pauli operators on the logical subsystem It is important to note that the stabilizer group of a subsystem code with local generators does not necessarily have local generators.This fact may make such subsystem codes potentially more powerful than stabilizer codes.Subsystem codes with an Abelian gauge group have no gauge qubits, i.e., L = L logical hence they coincide with the (subspace) stabilizer codes discussed above.Note that for (subspace) stabilizer codes the stabilizer group S coincides with the gauge group G.
The distance d of a subsystem code is defined as the minimum weight of a Pauli error P ∈ P preserving L and inducing a non-trivial transformation on L logical , Let us mention a useful identity that holds for any subsystem code G.Note that a subsystem code with a large distance must have a non-trivial stabilizer group.Indeed, if S = I , one has two possibilities: (i) any single-qubit Pauli operator belongs to G, and (ii) some single-qubit Pauli operator is a non-trivial logical operator.In case (i) one has G = P, i.e., the code has no logical qubits.In case (ii) one has d = 1.
The best known example of a locally generated subsystem code is the Bacon-Shor code [1,22] which can be defined on 2D or 3D lattice.The Hamiltonian H associated with the 2D Bacon-Shor code corresponds to the quantum compass model in condensed-matter physics, Here each pair i, j represents a vertex of the lattice and J x , J z are arbitrary real coefficients.Accordingly, the gauge group G of the 2D Bacon-Shor code has generators X i,j X i+1,j and Z i,j Z i,j+1 .This code has distance L. The stabilizer group S is generated by operators . One can easily check that all elements of S have weight at least 2L, that is, S cannot have local generators.The code has one logical qubit with logical Pauli operators The example of the Bacon-Shor code demonstrates that some subsystem codes with local generators originate from subspace codes with highly non-local stabilizer groups.It might suggest that subsystem codes can beat the upper bound Eq. ( 2).We will show that this intuition is wrong by proving Note that the distance of a subsystem code depends only on the gauge group G. Therefore, condition 1q is true or false for any Hamiltonian in the family Eq.( 8) regardless of the choice of coefficients r a .
As far as condition 2q is concerned, the first natural question is how to define the energy barrier d ‡ that must be traversed in order to implement a logical operator.In Section III B we propose a definition of d ‡ that depends on the energy spectrum of the Hamiltonian in different sectors L s .We also derive a usable upper bound on the energy barrier that does not require computing the energy spectrum.For any particular Hamiltonian this upper bound can be calculated using only the stabilizer formalism.Unfortunately, we have not yet been able to prove an analogue of Theorem 2 for subsystem codes.In Section III B we prove a very weak upper bound on d ‡ , namely, d ‡ = O(d).This leaves as an open question whether Hamiltonian models based on 2D subsystem codes may have a macroscopic energy barrier.

D. Organization of The Paper
The proof of Theorems 1-3 relies on three technical results, Lemma's 1-3.The first Lemma 1 which we call a "cleaning lemma" asserts that for any logical operator P ∈ C(S) and for any subset of qubits M , |M | < d, one can choose a stabilizer S ∈ S such that P S acts trivially on M .The stabilizer S involves only those generators S a whose support overlaps with M .Lemma 2 proves an analogue of this cleaning lemma for subsystem codes.The third Lemma 3 which we call a "restriction lemma" relates the distance of a code S defined on the entire lattice Λ and the distance of a code S M obtained by restricting generators of S onto some subset of qubits M ⊆ Λ.The restriction lemma applies to both subspace and subsystem stabilizer codes.
Stabilizer codes with local generators are discussed in Section II which proves Theorems 1 and 2. Subsystem codes with local generators are discussed in Section III.We prove the upper bound on the distance of subsystem codes (Theorem 3) in Section III A. Upper bounds on the energy barrier of subsystem codes are discussed in Section III B. Finally, Section III C shows how to prove Theorems 1 * and 2 * .Some open problems are discussed in Section IV.

II. STABILIZER CODES
Recall that P denotes the Pauli group on n qubits.We assume that the qubits live at vertices of a D-dimensional lattice Λ = {1, . . ., L} D .For any subgroup S ⊆ P and any subset M ⊆ Λ introduce a group S(M ) = {P ∈ S : Supp(P ) ⊆ M } which includes all elements of S whose support is contained in M .In particular, P(M ) is a group of all Pauli operators whose support is contained in M .Introduce also a group S M = {P ∈ P(M ) : P Q ∈ S for some Q ∈ P(Λ\M )} which includes all Pauli operators P ∈ P(M ) that can be extended to some element of S. In other words S M is a group obtained by restricting elements in S to M .Note that if some element P ∈ S crosses the boundary of M then the restriction of P onto M is no longer element of S. By definition S(M ) ⊆ S M ⊆ P(M ) ⊆ P.
Our main technical tool will be the following "cleaning" lemma.It allows one to clean out any region M ⊂ Λ of size smaller than the distance such that no logical operator of the code contains X, Y , or Z on qubits of M .More formally, one can multiply any logical operator P ∈ C(S) by a stabilizer S ∈ S such that P S acts trivially on M .The stabilizer S uses only those generators S a whose support overlaps with M , see Figure 1.The cleaning lemma is particularly useful when the generators of S are local.In this case the cleaning changes P only inside M and in a small neighborhood of the boundary of M .Thus the cleaning of P can be done multiple times, so that multiple 'holes' can be made into the support of P .
Lemma 1 (Cleaning Lemma).Let S = S 1 , . . ., S m be a stabilizer code and M ⊆ Λ be an arbitrary subset of qubits.Denote J (M ) a set of indexes a such that the support of S a overlaps with M .Then one of the following is true: (1) There exists a non-trivial logical operator P ∈ C(S)\S whose support is contained in M , (2) For any logical operator P ∈ C(S) one can choose a stabilizer such that P S acts trivially on qubits of M .
Proof.Let iI ⊆ P be a subgroup of phase factors.By definition of the subgroups S M and S(M ) one has the following inclusion: If the inclusion Eq. ( 12) is strict, there exists a Pauli operator P ∈ P(M ) such that P ∈ C(S M ) but P / ∈ S, that is, P ∈ C(S)\S.It corresponds to the case (1) in the statement of the lemma.Otherwise, Eq. ( 12) is an equality, that is, C(S M ) ∩ P(M ) = iI • S(M ).Taking the centralizer of both sides one gets (Note that for any subgroup T of the Pauli group one has C(C(T )) = iI •T .)Let P ∈ C(S) be any logical operator and P M be a restriction of P onto M .By definition, P M ∈ C(S(M )) ∩ P(M ).It follows from Eq. ( 13) that P M ∈ S M , that is, one can find a stabilizer S ∈ S such that P S acts trivially on M .Let us expand the stabilizer S in term of the generators and take out all generators whose support does not overlap with M .It yields a new stabilizer S ′ ∈ S such that P S ′ still acts trivially on M .On the other hand, S ′ is a product of generators S a , a ∈ J (M ), so we arrive at the case (2) in the statement of the lemma.
The proof of both Theorems 1 and 2 goes by applying the cleaning lemma to get an upper bound on a linear distance of a code that we define below.Let us first define a linear distance of a code when the lattice Λ = {1, . . ., L} D has open boundary conditions.Definition 1.Given a Pauli operator P ∈ P define its linear dimension d 1 (P ) as the minimum length of a contiguous interval R ⊆ {1, . . ., L} such that R × {1, . . ., L} D−1 covers the support of P .Given a stabilizer code S define a linear distance of S as Thus a linear distance of a code characterizes the minimal linear dimension of non-trivial logical operators along some fixed coordinate axis.Above we have chosen the first coordinate axis but one could similarly define a linear distance for any other coordinate axis.For periodic boundary conditions we define a linear dimension d 1 (P ) as the minimum length of a contiguous interval R ⊆ Z L such that R × (Z L ) D−1 covers the support of P .Then a linear distance of a code is defined by the same formula Eq. ( 14). for any L ≥ 2(r − 1) 2 .
Proof.We shall prove the proposition for D = 2.The generalization to other dimensions is straightforward.Let us assume that the bound Eq. ( 15) is not satisfied, that is, and show that it leads to a contradiction.The idea behind the proof is depicted in Fig. 2. One can easily check that any integer L ≥ 2(r−1) 2 can be represented as L = a(r−1)+br for some integers a, b ≥ 0 such that K ≡ a+b is even.Therefore we can represent the lattice Λ as a disjoint union of vertical strips, Λ = A 1 ∪. ..∪AK , such that any strip has width (along the xaxis) r or r − 1, and the total number of strips K is even, see Fig. 2. The assumption Eq. ( 16) implies that any nontrivial logical operator P ∈ C(S)\S is supported on at least two strips.Therefore, Lemma 1 implies that we can multiply P with some product of generators S a to clean out any chosen even strip A 2 , A 4 , . . ., A K .However, a support of any generator S a has width at most r and FIG.2: Theorem 1: sketch of the proof.Choose any logical operator P ∈ C(S)\S.Assuming d1(S) > r, we can clean out any vertical strip of width r.Repeating this procedure on parallel disjoint strips (even strips), we obtain an equivalent logical operator P ′ which has support on the remaining set of disjoint strips (odd strips).If the strips are wide enough, then P ′ commutes with S on every odd strip individually.It must be that the restriction of P ′ on some odd strip is not in S, otherwise P ′ ∈ S. Thus we obtain a non-trivial logical operator whose support is contained in a single vertical strip which contradicts the assumption that d1(S) > r.
thus it overlaps with at most one even strip, so we can apply Lemma 1 repeatedly to clean out all even strips.In other words, we can define a new logical operator P ′ = P S, for some S = p=2,4,...,K a∈J (Ap) S xa a such that P ′ is supported only on odd strips, that is Next we note that each generator S a overlaps with at most one odd strip.Therefore the inclusion P ′ ∈ C(S) is possible only if P ′ j ∈ C(S) for all j = 1, 3, . . ., K − 1.Since P ′ / ∈ S there must exist at least one odd strip A j such that P ′ j / ∈ S, that is, P ′ j is a non-trivial logical operator.However it contradicts Eq. ( 16) since the linear dimension d 1 (P j ) is at most r.
Theorems 1 and 2 are direct corollaries of Proposition 1. Indeed, choose any logical operator P ∈ C(S)\S with a linear dimension d 1 (P ) ≤ r.Then the weight of P is at most rL D−1 , that is, d ≤ rL D−1 which proves Theorem 1. Furthermore, if D = 2 then the bound d 1 (P ) ≤ r implies that the support of P can be covered by a quasi-1D vertical string.One can construct a walk γ ∈ W(I, P ) that implements P in a row-by-row fashion.At any intermediate step the contribution to the energy cost of a partially implemented P comes only from the two end-points of the string.The assumption that any qubit participates in O(1) generators S a implies that ǫ max (γ) = O(1).It proves Theorem 2.
Remark: After having tried to construct 3D stabilizer codes with d = O(L 2 ) which would saturate the bound in Eq. ( 2), we conjecture that any 3D stabilizer code with local generators satisfies d = O(L).In fact, all known examples of stabilizer codes correspond to a bound d = O(L ⌊D/2⌋ ).The pattern that seems to emerge is that there is a trade-off between the minimum weight of, say, the logical X versus logical Z operator.The 1D repetition code shows that one can have a logical X of weight O(L), but then the logical Z is of weight O(1), so the distance of the code is O(1).In 2D, one can make both operators of weight O(L) as the surface codes demonstrate.In 3D, the 3D toric code is an example where again one logical operator is of weight O(L 2 ) but the other logical operator is of weight O(L).In 4D, both operators are of weight O(L 2 ).

III. SUBSYSTEM CODES A. Bounds on The Code Distance
Let us start by generalizing the cleaning lemma to subsystem codes.

Lemma 2 (Cleaning Lemma for Subsystem Codes). Let G be a gauge group of a subsystem code and M be an arbitrary subset of qubits. Then one of the following is true:
(1) There exists a non-trivial logical operator P ∈ C(S)\G whose support is contained in M , (2) For any logical operator P ∈ C(G) one can choose a stabilizer S ∈ S such that P S acts trivially on M .Proof.Let iI ⊆ P be a subgroup of phase factors.By definition of the subgroups S M and G(M ) one has the following inclusion: If the inclusion Eq. ( 17) is strict, there exists a Pauli operator P ∈ P(M ) such that P ∈ C(S M ) but P / ∈ G, that is, P ∈ C(S)\G.It corresponds to case (1) in the statement of the lemma.Otherwise Eq. ( 17) is an equality, that is, iI • G(M ) = C(S M ) ∩ P(M ).Taking the centralizer of both sides one gets Let P ∈ C(G) be any logical operator and P M be a restriction of P onto M .By definition, P M ∈ C(G(M ))∩P(M ).It follows from Eq. ( 18) that P M ∈ S M , that is, one can find a stabilizer S ∈ S such that P S acts trivially on M .
Note that cleaning out the region M may require changing the operator P globally (not only in a small neighborhood of M ) since the stabilizer group S of a subsystem code may lack a local generating set.This is the reason why for subsystem codes we cannot clean out multiple disconnected regions simultaneously: cleaning out one region by multiplying with elements in S may generate support in another 'far-away' region which we already cleaned out.
On the other hand, if the stabilizer group S = G ∩C(G) has local generators, S = S 1 , . . ., S m , the operator S in Lemma 2 can be chosen such that it includes only those generators S a whose support overlaps with M .In this case the cleaning can be performed "locally".
For subsystem codes we shall need a new lemma which relates the distance of a code G defined on the entire lattice Λ to the distance of a code G M obtained by restricting G onto some subset of qubits M ⊆ Λ (here we use notations introduced in Section II).Recall that l ∞ -distance between vertices u, v ∈ Λ is defined as max D j=1 |u j − v j |.
Lemma 3 (Restriction Lemma).Let G = G 1 , . . ., G m be a gauge group of a subsystem code on a D-dimensional lattice Λ. Suppose the support of any generator G a can be bounded by a hypercube with r D vertices.Let M ⊆ Λ be an arbitrary subset and ∂M be a subset of vertices u ∈ Λ\M such that l ∞ -distance between u and M is at most r.Consider the subsystem code with gauge group G M .Then one of the following is true: (1) The code G M has no logical qubits, (2) The code G M has distance at least d − |∂M | where d is the distance of G defined in Eq. ( 9).
Remark: By abuse of notation we regard the code G M as a code defined on qubits of M only (otherwise any Pauli operator on a qubit u ∈ Λ\M would be a logical operator for the code G M ).One can always extend the code G M to the rest of the lattice in a trivial way, for example, by adding a gauge operator Z u for any qubit u ∈ Λ\M .For simplicity we shall ignore these technicalities.Now we are ready to apply these Lemma's to prove Theorem 3.For simplicity we present a proof for D = 1 and open boundary conditions.Generalization to higher dimensions and periodic boundary conditions is straightforward.In 1D we have to prove the upper bound Let M ⊆ Λ be the smallest contiguous block of qubits such that the subsystem code G M obtained by restricting G onto M has at least one logical qubit (if there are several minimal blocks M , choose anyone of them).Let d ′ be the distance of the code G M .The restriction lemma implies that Let us assume that d ′ > r and show that it leads to a contradiction.Indeed, d ′ > r implies |M | > r, so we can partition M into three contiguous blocks, M = ABC, such that |B| = r − 1 and A, C = ∅.Let P, Q ∈ C(G M )\G M be any pair of anti-commuting logical operators for the code G M .Since the size of B is smaller than the distance of G M , we can apply Lemma 2 to the code G M to clean out the region B which yields a pair of "cleaned" logical operators Combining this observation with the fact that P A and Q A anti-commute we conclude that neither of P A , Q A can be an element of G M , that is Consider the subsystem code G A obtained by restricting G M onto A. We want to argue that P A , Q A are non-trivial logical operators for the code G A .Indeed, by definition, . Since P A and Q A anti-commute, neither of them can be an element of G A , that is, Summarizing we have found a contiguous block A ⊂ M , |A| < |M |, such that the code G A has at least one logical qubit.This however contradicts the minimality of M and thus proves that d ′ ≤ r.Taking into account Eq. ( 20) we arrive at d ≤ 3r.The proof of Theorem 3 for 2D subsystem codes is analogous.In that case we would consider the minimal width strips M of height L such that G M has at least one logical qubit.The same approach generalizes to arbitrary dimensions D.

B. Energy Barrier Upper Bounds
Let us start by describing some general properties of the Hamiltonian H defined in Eq. (8).Recall that we define a gauge group G ⊂ P as a group generated by Pauli operators G a in the Hamiltonian Eq. ( 8).We define a stabilizer group S as the center of G, i.e., S = G ∩ C(G).The stabilizer group induces a decomposition of the Hilbert space of n qubits into G-invariant sectors, (C 2 ) ⊗n = s L s , where s labels different syndromes (irreps of S).By definition, H is block-diagonal with respect to this decomposition, Each sector L s possesses a subsystem structure L s = L logical,s ⊗ L gauge,s .The Hamiltonian H s acts trivially on the 2 k -dimensional logical subsystem L logical,s and has a non-trivial spectrum of gauge qubit excitations (which may be different for different sectors s).
The question of whether such Hamiltonian can be a model of a self-correcting memory is more involved than for stabilizer codes and goes beyond this paper.One of the first questions is to determine whether the groundspace of the Hamiltonian is confined to one sector, and if so, whether the excitations from this sector, call it s 0 , to the other sectors are gapped.The fulfillment of such conditions would show that the Hamiltonian has some stability with respect to perturbations that affect the logical qubits.This condition is naturally obeyed for stabilizer code Hamiltonians.Note that we do not require the gauge-qubit excitations in a fixed sector to be gapped, since these excitations do not harm the state of the logical qubits.In particular, there may be low-lying or gapless gauge-qubits excitations from the ground-space which give rise to a local order parameter, see for example the discussion of the quantum compass model in [9].The presence of a local order for the gauge qubits, i.e. a local operator acting on the gauge qubits which distinguishes two different ground-sectors, does not at all prevent the possibility of a 'topological order' for the logical qubits.It only expressed the fact that the gauge qubits are not a good place to put the quantum information.
Let us define the gap where λ(H s ) is the smallest eigenvalue of H s and s 0 is the sector that contains the smallest eigenvalue of H.
A proper definition of the energy barrier that must be traversed in order to perform a logical operation is dependent on the energy spectrum of the Hamiltonian in different s sectors.Consider a logical operator E ∈ C(S)\G and let γ ∈ W(I, E) a walk on the Pauli group implementing E. In order to define the energy cost of a Pauli operator E, we consider what the operator does on the s 0 sector.Any state in the s 0 sector will be mapped onto a state in some other fixed sector s.We define the energy cost of E as Let the maximum energy barrier along a path be ǫ max (γ) = max P ∈γ ǫ(P ).Then we define the energy barrier for E as The minimum over these energy barriers for any logical operation is then given by In the definition of d and d ‡ we minimize over elements of C(S)\G which are comprised of a 'bare' logical operator (an element of C(G)\G) times any gauge operator (an element of G), see Eq. (10).The minimum weight of operators in C(S)\G may be much less than the minimum weight of 'bare' logical operators.A good example is the Heisenberg model on a D-dimensional lattice where G is generated by nearest-neighbor XX, Y Y and ZZ operators.If L is odd, the operators X all = u∈Λ X u and Z all = u∈Λ Z u commute with G but are not generated by G.In addition we have S = I.This implies that the minimal weight of the bare logical operators in C(G)\G is L D .However, the distance d of this code is 1, because we can reduce the weight of, say, X all to 1 by multiplying with it with XX-type gauge operators.If some gauge qubits operations are costly to implement (i.e.require creating high-energy excitations) then it may be more physically reasonable to not count these operations for free in minimizing the distance and the energy barrier.Whether such choices are warranted however depends on the features and spectrum of the Hamiltonian and cannot be analyzed using the coding framework alone.
In order to set the stage for proving no-go results which do not depend on detailed properties of the Hamiltonian, we will derive a simple upper bound on the energy cost of a Pauli operator E defined in Eq. ( 22).We apply this analysis to the Hamiltonian defined in Eq. ( 8) assuming for simplicity that r a = −1, that is, Let E ∈ P be any Pauli error mapping the ground state sector L s0 to some sector L s and let |ψ 0 be a ground state of H s0 , such that λ(H s0 ) = ψ 0 |H|ψ 0 .Since E |ψ 0 ∈ L s we get an upper bound λ(H s ) ≤ ψ 0 |E † HE|ψ 0 .It implies We can bound the norm of the commutator [H, E] taking into account that E either commutes or anti-commutes with any generator G a .It yields Summarizing we can bound the energy cost of E by (twice) the number of terms in the Hamiltonian anticommuting with E. Note that this upper bound is identical to the definition of energy cost for stabilizer codes, Eq. ( 4).The upper bound Eq. ( 25) opens up the possibility for a generalization of the energy barrier arguments in Section II to subsystem codes.For example, one can use Eq. ( 25) to show that d ‡ = O(1) for the 2D Bacon-Shor code.This easily follows from the fact that a partially implemented logical operator (say, X = i X 1,i ) only anti-commutes with the gauge operators ZZ at the endpoints.(Numerical results of [21] indicate that d ‡ decays exponentially with the lattice size L.) Using Eq. ( 25) we can also show that d ‡ = O(d).Indeed, choose a non-trivial logical operator P = P u1 . . .P u d ∈ C(S)\G with weight d.The number of generators G a anti-commuting with any single-qubit operator P ui is at most O(1).Therefore the number of generators anti-commuting with P is at most O(d).Implementing the sequence of the single-qubit Pauli operators P u1 , . . ., P u d in an arbitrary order one gets a walk γ ∈ W(I, P ) with ǫ max (γ) = O(1).
C. Proofs of Theorem 1 * and 2 * Let S = S 1 , . . ., S m be a stabilizer code with local generators, and let X 1 , Z 1 , . . ., X g , Z g be logical Pauli operators on some subset of g logical qubits (the ones we want to treat as gauge qubits).Let G = S, X 1 , Z 1 , . . ., X g , Z g .We can regard G as the gauge group of a subsystem code.Clearly, G ∩C(G) = S, so S is the stabilizer group of G.In order to prove Theorems 1 * and 2 * let us define a linear distance of a subsystem code.
Recall that d 1 (P ) is a linear dimension of P , that is, the minimal length of a contiguous interval R ⊆ {1, . . ., L} such that R × {1, . . ., L} D−1 covers the support of P , see Section II.Thus a linear distance of a code characterizes the minimal linear dimension of non-trivial logical operators along some fixed coordinate axis.Proof.The proof is almost identical to the proof of Proposition 1 in Section II.It goes by assuming that d 1 (G) > r and showing that it leads to a contradiction.The only difference is that instead of cleaning out a logical operator P ∈ C(S)\S using Lemma 1 one has to clean out a logical operator P ∈ C(G)\G using Lemma 2. After cleaning out all even strips A 2 , . . ., A K one gets an equivalent logical operator P ′ ∈ C(G)\G that has support only on odd strips A 1 , A 3 , . . ., A K−1 (we used the notations from the proof of Proposition 1).Since any generator of S overlaps with at most one odd strip, the inclusion P ′ ∈ C(G) ⊆ C(S) implies that a restriction of P ′ onto any odd strip is an element of C(S).At least one of these restrictions is not an element of G. Therefore, a restriction of P ′ onto some odd strip is an element of C(S)\G.This is in contradiction with the assumption that d 1 (G) > r.
Theorems 1 * and 2 * are direct corollaries of Proposition 2. Indeed, choose any logical operator P ∈ C(S)\G with a linear dimension d 1 (P ) ≤ r.Then the weight of P is at most rL D−1 , that is, d(G) ≤ rL D−1 which proves Theorem 1 * .Furthermore, if D = 2 then the bound d 1 (P ) ≤ r implies that the support of P can be covered by a quasi-1D vertical string and thus one can construct a walk γ ∈ W(I, P ) with ǫ max (γ) = O(1).It proves Theorem 2 * .

IV. DISCUSSION AND OPEN PROBLEMS
This paper addressed the problem of constructing a self-correcting quantum memory based on stabilizer codes with geometrically-local generators.We developed several technical tools for analyzing such codes and proved upper bounds on the distance that are tight for 1D and 2D codes.In addition, we defined an energy barrier separating different logical states and proved that for 2D stabilizer codes the energy barrier can not grow with the lattice size.We note that a similar conclusion has been independently reached by Kay and Colbeck [23] using completely different techniques.
It would be interesting to prove our conjecture that d = O(L) for stabilizer codes in 3D.In addition, we would like to bound the energy barrier d ‡ for 3D stabilizer codes and for 2D subsystem codes.It might be possible that a self-correcting quantum memory can only be based on 3D subsystem codes such as the one suggested by Bacon [1].This would require a detailed analysis of the energy barrier for these systems.
Another interesting problem concerns algorithms for computing the distance of stabilizer codes with local generators.The dynamic programming algorithm allows one to compute the distance of stabilizer (subsystem) codes with local generators in time of order L exp (L D−1 ).It requires exponential time for D ≥ 2. It remains an open question whether the distance can be computed in polynomial time for D ≥ 2.
only to project onto a certain eigenvalue of the stabilizer [28] A generalized toric code on a D-dimensional lattice has qubits living on hypercubes of dimension D ′ ≡ ⌊D/2⌋, Xtype stabilizers living on hypercubes of dimension D ′ +1, and Z-type stabilizers living on hypercubes of dimension D ′ −1.Logical X-type operators correspond to closed hypersurfaces of dimension D ′ and logical Z-type operators correspond to closed hypersurfaces of dimension D − D ′ on the dual lattice.
[29] If we would only consider the minimum weight of elements of C(G)\G, that is the weight of 'bare' logical operators on the logical qubits, one can easily construct 1D counterexamples to Theorem 1 * .Take (odd) n copies of a small code, such as the Steane code [ [7,1,3]] and define two high-weight logical operators as X = X1X2 . . .Xn and Z = Z1Z2 . . .Zn.Here Xi, Zi are the logical operators for the ith Steane code.It is clear that even when we multiply these operators X and Z with elements in S, their minimum weight will scale with n.Aside from this logical qubit there are also gauge qubits.If we multiply X, Z with the logical operators of these gauge qubits, we can reduce the weight of X or Z to O(1).
[30] It is well known that the codes corresponding to different choices of the syndrome s are equivalent up to a local change of basis in every qubit.

Theorem 3 .
Let G = G 1 , . . ., G m be the gauge group of a subsystem stabilizer code on a D-dimensional lattice Λ = {1, . . ., L} D .Suppose the support of any generator G a can be bounded by a hypercube with r D vertices.Then the distance of G satisfies d ≤ 3rL D−1 .

FIG. 1 :
FIG. 1: Support of a logical operator P ∈ C(S) is shown by the colored dots (representing X, Y , and Z operators).In order to clean out the region M (interior of the dashed ellipse) one can multiply P with a stabilizer S ∈ S. The stabilizer S includes only those generators Sa whose support overlaps with M .It yields an equivalent logical operator P S acting trivially on M .The cleaning can performed simultaneously for different logical operators and for different spacial regions.

Proposition 1 .
Let S = S 1 , . . ., S m be a stabilizer code on a lattice Λ = {1, . . ., L} D with open or periodic boundary conditions.Suppose the support of any generator S a can be covered by a hypercube with r D vertices.Then d 1 (S) ≤ r (15) Proof.Indeed, suppose G M has at least one logical qubit and let d ′ be the distance of G M .Then there exists a logical operator P ∈ C(G M ) ∩ P(M ), P / ∈ G M and a gauge operator G ∈ G M such that |P G| = d ′ .Then P ∈ C(G)\G, that is, P is a non-trivial logical operator for the original code.By definition of the group G M , we can extend the operator G ∈ G M beyond M to some gauge operator G ′ ∈ G such that G is the restriction of G ′ onto M .Since G has local generators, such an operator G ′ can be chosen to have support only in M and in ∂M .It means that |P G ′ | ≤ d ′ + |∂M |.Since P G ′ is a nontrivial logical operator for the code G, its weight must be at least d, or d ≤ d ′ + |∂M |.

Definition 2 .
Given a subsystem code G define a linear distance of G as d 1 (G) = min P ∈C(S)\G d 1 (P ).

Proposition 2 .
Let G be a subsystem code on a lattice Λ = {1, . . ., L} D with open or periodic boundary conditions.Assume that a stabilizer group S = G ∩ C(G) has local generators, S = S 1 , . . ., S m , such that the support of any generator S a can be covered by a hypercube with r D vertices.Thend 1 (G) ≤ r (27)for any L ≥ 2(r − 1) 2 .
Assume without loss of generality that P A anti-commutes with Q A (otherwise, relabel the blocks A and C).Since the code G M has local generators of size at most r and the block B has length r − 1, no generator of G M overlaps with both A and C. Therefore P