Optimal Locality and Parameter Tradeoffs for Subsystem Codes
Abstract
We study the tradeoffs between the locality and parameters of subsystem codes. We prove lower bounds on both the number and lengths of interactions in any -dimensional embedding of a subsystem code. Specifically, we show that any embedding of a subsystem code with parameters into must have at least interactions of length at least , where
We also give tradeoffs between the locality and parameters of commuting projector codes in -dimensions, generalizing a result of Dai and Li [8]. We provide explicit constructions of embedded codes that show our bounds are optimal in both the interaction count and interaction length.
Keywords and phrases:
Quantum Error Correcting Code, Locality, Subsystem Code, Commuting Projector CodeFunding:
Ray Li: Supported by NSF grant CCF-2347371.Copyright and License:
2012 ACM Subject Classification:
Hardware Quantum error correction and fault tolerance ; Theory of computation Error-correcting codesAcknowledgements:
We thank Andy Liu, Shouzhen Gu, Zhiyang He for helpful feedback on our manuscript.Event:
20th Conference on the Theory of Quantum Computation, Communication and Cryptography (TQC 2025)Editor:
Bill FeffermanSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
Quantum computing necessitates the manipulation of fragile states of information. The most promising way towards large-scale fault-tolerant quantum computing involve the extensive use of quantum error-correcting codes (QECCs). Physical implementations of quantum computing hardware naturally favor architectures which are local in or spatial dimensions – architectures where the qubits are embedded in 2 or 3 dimensions, and interactions occur only between qubits that are spatially nearby. On the other hand, it has long been known that the constraint of spatial locality places severe limitations on the parameters of QECCs. For example, the Bravyi-Terhal [7] and Bravyi-Poulin-Terhal (BPT) [6] bounds state that a commuting projector code whose constraints are local in -dimensions necessarily have code parameters satisfying, respectively,
| (1) |
These bounds suggest that there are tradeoffs between better code performance and the cost of non-local implementation. Consequently, the locality of a QECC becomes another key factor to consider when choosing a code for applications.
What is the quantitative tradeoff between locality and code quality? This problem was initially investigated by Baspin and Krishna [3], who asked, for a quantum low-density parity-check (qLDPC) code in -dimensions, how many “long-range” interactions must there be, and how long must those interactions be? Baspin and Krishna gave bounds for -dimensional codes which are nearly optimal in certain parameter settings. For -dimensional codes, Dai and Li [8] improved the bounds to be tight across all parameter regimes and also gave matching constructions that saturate the upper bounds (see also Hong, et al. [11], who considered the special case for 2-dimensional codes). Dai and Li showed that an quantum code embedded in spatial dimensions must have interactions of length , where
| (2) |
Both the interaction count and interaction length are tight in strong ways.
In this paper, we study the locality versus parameter tradeoffs for quantum subsystem codes. Bravyi [5] showed that the BPT bound could be violated by the use of local subsystem codes, providing D-local subsystem codes with parameters . Subsystem codes are nevertheless constrained by locality. Bravyi [5] showed that a subsystem code whose gauge generators are local in a -dimensional lattice embedding satisfies
| (3) |
While previous work has made it clear that outperforming local quantum codes requires copious amounts of long-ranged interactions, it is not a priori clear whether the same requirements hold for subsystem codes. Is it possible that small violations of locality in the gauge generators suffice to define subsystem codes parametrically better than those allowed by Bravyi’s bound? More concretely:
Question 1.
How much non-locality is required for a subsystem code to exceed Bravyi’s bound?
We address Question 1 by demonstrating that subsystem codes, like their commuting projector counterparts, require an extensive number of long-ranged interactions to surpass Bravyi’s bound. We also provide constructions of subsystem codes that show our lower bounds are tight in strong ways. Additionally, we also generalize the results of Dai and Li [8] from -dimensions to -dimensions. Our work establishes optimal bounds on interaction lengths and counts for embeddings of both commuting projector codes and subsystem codes in any number of dimensions.
1.1 Main Result
We study subsystem codes whose gauge generators are not necessarily local. Our main result is a lower bound on the number and length of interactions in any -dimensional embedding of a subsystem code. Formally, a -dimensional embedding is a mapping of the code’s physical qubits into , such that any two qubits are at distance at least 1.
Theorem 2 (Main Result for Subsystem Codes).
For any , there exist constants and such that the following is true: Any -dimensional embedding of a nontrivial111Nontrivial here simply means that . subsystem code with or must have at least interactions of length , where
| (4) |
Prior to this work, no such bounds of this form were known for subsystem codes aside from Bravyi’s original bound. While such bounds were known for commuting projector codes, our bound shows that a locality versus parameter trade-off also holds for subsystem codes. Our result also generalizes Bravyi’s bound [5], not only in that we (optimally) address the number and length of long-range interactions, but also in that we handle more general embeddings. Bravyi’s bound [5] considers only embeddings onto a lattice, but our bound applies to arbitrary embeddings, even those not constrained to a box (see Section 3 for further discussion).
Like for stabilizer codes, subsystem codes beyond the “local regime” – above the BPT bound for stabilizer codes, or above the Bravyi bound for subsystem codes – need copious amounts of non-locality. In particular, the number of required long-range interactions is the same for both subsystem and stabilizer codes. Additionally, for codes with a large number of logical qubits, the required length of the long range interactions is similar. For example, a -dimensionally embedded asymptotically good subsystem code (with ) needs interactions of length – the worst possible case – just as for stabilizer codes. Our results show that, compared to stabilizer codes, subsystem codes do not offer substantial improvements in locality outside of the “local regime,” though they can offer some quantitative improvements in the interaction length.
We also provide matching constructions that show and are optimal in strong ways (see Figure 2). An asymptotically good qLDPC code [14, 12] has interactions of any length (see Theorem 1.3 of [8]). Since a stabilizer code can also be trivially regarded as a subsystem code, this shows that our bounds are tight in terms of interaction count. For optimality in the interaction length, we exhibit subsystem codes embedded in -dimensions where all interactions are of length at most (Theorem 21).
1.2 Generalizing [8] to -dimensions
We also show that the bounds in [8] can be generalized to -dimensional embeddings and to commuting projector codes.
Theorem 3 (Generalization of [8] to -dimensions).
For any , there exist constants and such that the following is true: Any -dimensional embedding of a nontrivial commuting projector code with or must have at least interactions of length , where
| (5) |
We now compare our works to prior works. First, we note that, when setting , our bound matches the bounds in [8] up to the implied constant. For dimensions, the only prior bounds we are aware of are due to Baspin and Krishna [3]. Theirs match our bounds up to polylog factors when and when , and we improve their bounds in the remaining parameter regimes. We also generalize their results; our results hold for all commuting projector codes, whereas theirs hold only for qLDPC codes.
Similar to Theorem 2 and [8], our and in Theorem 3 are optimal up to constant factors. Any asymptotically good qLDPC code [14, 12] is a commuting projector code with at most interactions of any length. Further, we exhibit stabilizer codes embedded in dimensions, all of whose interactions are of length at most ; see Theorem 23.
1.3 Organization of the Paper
We divide the proof of Theorem 2 into two parts:
Theorem 4 (Main Result – Part 1).
For all , there exist constants and such that the following is true: Any -dimensional embedding of a nontrivial subsystem or commuting projector code with must have at least interactions of length at least .
Theorem 5 (Main Result – Part 2).
For all , there exist constants and such that the following is true: Any -dimensional embedding of a subsystem code with must have at least interactions of length at least .
Theorem 4 implies Theorem 2 in the regime where , and Theorem 5 implies Theorem 2 in the regime when . Note that Theorem 4 also implies Theorem 3 when . The remaining case of Theorem 3 is when , which we prove in Theorem 6.
Theorem 6 (Generalization of [8] when ).
For all , there exist constants and such that the following is true: Any -dimensional embedding of a commuting projector code with must have at least interactions of length .
2 Preliminaries
Notation and Definitions
We use standard Landau notation . We also use the notations , which are variants of and , respectively, that ignore logarithmic factors. For example, means that there exists an integer such that . For a set , we write .
In , distance refers to Euclidean () distance unless otherwise specified. We sometimes also use the -distance of two points , which is . A grid tiling is a division of given by axis aligned hyperplanes equally spaced at a fixed distance . Throughout, a box is always a set of the form . In particular, boxes contain their boundary and are axis-parallel. A cube is a box all of whose side lengths are equal: .
An embedded set in is a finite set with pairwise () distance at least 1. A function is finitely supported if for finitely many . For a finitely supported function and a region , define, by abuse of notation, . We will be primarily concerned with the finitely supported function given by Definition 8.
2.1 Quantum codes
We associate the pure states of a qubit with unit vectors in and pure -qubit states with unit vectors in . Let denote the (single-qubit) Pauli group, which consists of the Pauli matrices , and their scalar multiples by . The -qubit Pauli group is . Given , its weight is the number of tensor components not equal to .
A quantum error-correcting code is a subspace of . The parameter is called the (block) length of the code. We define the dimension of the code to be .
Stabilizer Codes
A stabilizer group is an abelian subgroup of the -qubit Pauli group that does not contain . A stabilizer code is defined to be the subspace of states left invariant under the action of the stabilizer group , i.e. . Being an abelian group, we can describe by independent generators , where is the dimension of the code. The distance is the minimum weight of an error that maps a codeword in to another codeword. A quantum code with distance can correct up to qubit erasures.
Subsystem Codes
A subsystem code is a choice of decomposition of a stabilizer code into a tensor product , where and are the logical and gauge parts of , respectively. The dimension of a subsystem code is defined as the number of qubits encoded in its logical subsystem . One can view a subsystem code as a stabilizer code that can encode logical qubits, but only of the logical qubits are actually used to protect information.
We can define a subsystem code by starting with a stabilizer code given by independent stabilizer generators, with logical qubits associated with pairs of logical operators . The first logical qubits are used to encode information, and the last logical qubits are called gauge qubits. The gauge group of the subsystem is the group . Given the gauge group , the code’s stabilizer group can be recovered as the center of , so a subsystem code is uniquely defined by its gauge group. Any stabilizer code can be equivalently regarded as a subsystem code whose gauge group is abelian, so stabilizer codes form a subset of subsystem codes.
For subsystem codes, we make a distinction between bare logical operations, which act trivially on the gauge qubits, and dressed logical operators, which may not. Formally, (non-trivial) bare logical operators are elements of , where denotes the centralizer of , and (non-trivial) dressed logical operators are elements of . Note that for stabilizer codes there is no distinction. The distance of a subsystem code is defined as the minimum weight of a non-trivial dressed logical operator, i.e., . We will sometime denote a subsystem code with physical qubits, logical qubits, distance , and gauge qubits by .
Commuting Projector Codes
A commuting projector code is a subspace defined by a set of pairwise commuting projections . The code is the subspace of states left invariant by all projections . Every stabilizer code is also a commuting projector code where the defining projections are of Pauli type, i.e., , for some Pauli operator . For the purposes of establishing our locality bounds, the only properties we need of commuting projector codes is the fact that all the properties of correctable sets for stabilizer codes, i.e., those listed in Lemma 11, continue to hold without modification for commuting projector codes [10]. Finally, we note that while stabilizer codes can be considered a subset of both subsystem and commuting projector codes, there is no direct relation between subsystem and commuting projector codes themselves.
Quantum codes in dimensions
Given a finite set , an embedding of into is a map such that for all distinct . The image is then said to be an embedded set. Throughout, the embedding map will usually be implicit. We identify the qubits of a quantum code with a -dimensional embedded set, which we continue to call by abuse of notation. By further abuse of notation, we refer to as the embedding of the qubits . When the set of qubits is understood, given a subset , we write to denote the complement of in .
Definition 7 (Interactions).
Given an embedding of a quantum code , either a commuting projector code or a subsystem code, interactions of the code are defined with respect to a specific set of generators for that code. In the case that is a commuting projector code with defining projections , we say that a pair of qubits define an interaction if and are both in the support of some projection . Similarly, if is a subsystem code with a set of generators for its gauge group, we say that define an interaction if and are both in the support of some gauge generator . In both cases, the length of an interaction is defined to be the distance between and .
Interactions are always defined with respect to a particular set of generators (either projector or gauge), but throughout we assume that the generator set is fixed (but otherwise arbitrary), and thus the set of interactions is fixed as well. Note that for subsystem codes, interactions are always defined with respect to gauge generators and not stabilizer generators. In particular, since each stabilizer generator is generally a product of multiple gauge generators, it is possible for a subsystem code to have local gauge generators, but non-local stabilizer generators. Indeed, it is only in such cases that a separation in the locality bounds for stabilizer and subsystem codes is possible.
In the proofs of our results, we typically consider a fixed interaction length . We then refer to an interaction as bad if the length is at least and as good if the length is less than . Intuitively, good interactions are easier to deal with for our proof; they are effectively local, and can be treated in a similar to how local interactions are treated in the original proofs of the BPT and Bravyi bounds. To control the number of bad interactions, we introduce the following function that counts the number of bad interactions that a particular qubit participates in:
Definition 8 (Interaction counter).
Given a quantum code with a -dimensional embedding , let denote the interaction counting function, where for equals the number of interactions of length at least that qubit participates in, and outside of .
Correctable sets
Like in previous works [2, 3, 1, 8], we analyze the limitations of quantum codes using correctable sets. Intuitively, a subset of qubits is correctable if the code can correct the erasure of the qubits in . We state the definition of a correctable set for completeness, though we only interface with the definition indirectly using Lemmas 11, 12, and 13.
Definition 9 (Correctable set).
Let be a subset of qubits in a quantum code, and let . Let and denote the space of density operators associated with the sets of qubits and respectively. The set is correctable if there exists a recovery channel such that for any code state , we have .
For an embedded set of qubits , we will say that a region is correctable if the subset of all qubits contained in is a correctable subset. As an abuse of terminology, we will often refer to subsets of qubits as regions. For stabilizer and commuting projector codes, a region being correctable is equivalent to having no non-trivial logical operators supported on that region. For subsystem codes, a region is correctable if and only if no non-trivial dressed logical operators are supported on . Note that being correctable also implies that no non-trivial bare logical operators are supported on , but the converse does not necessarily hold. This motivates the following definition.
Definition 10 (Dressed-Cleanable).
If there are no non-trivial bare logical operators supported on a region , then we say that is dressed-cleanable [15].
We use the following notions in Lemma 11 to reason about correctable sets in subsystem codes and commuting projector codes. In a quantum code with qubits , say sets are decoupled if there are no interactions between two distinct ’s. For a set , let be the boundary of , where denotes the outer boundary of , the set of qubits outside that have an interaction with , and is the inner boundary of .
Lemma 11 ([7, 10, 15]).
Let be the qubits of a commuting projector or subsystem code .
-
1.
Subset Closure: Let be a correctable set. Then any subset is correctable.
-
2.
Distance Property: Let with . Then is correctable.
-
3.
Union Lemma: Let be decoupled, and let each be correctable. If is a subsystem code, then is dressed-cleanable. If is a commuting projector code, then is correctable.
-
4.
Expansion Lemma: Let be correctable sets such that . Then is correctable.
A key point in Lemma 11 is that the union lemma differs for commuting projector and subsystem codes. For subsystem codes, the union of decoupled and correctable sets is not necessarily correctable – only dressed-cleanable [15]. In general, being dressed-cleanable is weaker than being correctable. One of the major problems with generalizing Theorem 3 from commuting projector codes to subsystem codes is that the union lemma for subsystem codes only allows the conclusion that the union of correctable sets is dressed-cleanable. This version of the union lemma is too weak to adapt the original proof of Theorem 3 to subsystem codes. Instead, we take an alternative approach in proving Theorem 4 which is based solely on the expansion lemma.
The usefulness of reasoning about correctable sets is that the sizes of the correctable sets in a quantum code directly give bounds on the parameters:
Lemma 12 ( Lemma – Implicit in [5], Section VIII).
Suppose that the qubits of a subsystem code can be partitioned as . If is dressed-cleanable, then
Lemma 13 ( Lemma [6]).
Suppose that the qubits of a commuting projector code can be partitioned as . If and are correctable, then .
2.2 Geometric Lemmas
In this section, we give two lemmas about -dimensional embeddings of sets. The first, Lemma 14, allows us to generalize our results from lattice embeddings to arbitrary embeddings.
Lemma 14 (Point Density).
Let be a box with side lengths . Suppose is an embedded set. Then
| (6) |
where is the unit ball in .
We refer the reader to [9] for the proof.
The second lemma, Lemma 15, utilizes the probabilistic method to generate a grid tiling that allows us to maintain a convenient distribution of the qubits and bad interactions in our embeddings (see Figure 3).
Lemma 15 (Tiling Lemma).
Let be two multi-sets. Let and be positive integers with . There exists a tiling of using hypercubes of side length such that:
-
1.
at most a fraction of points in are within -distance of a codimension- face of some hypercube,
-
2.
at most a fraction of points in are within -distance of a codimension- face of any hypercube.
We refer the reader to [9] for the proof.
3 Proof of Theorem 4
We now prove Theorem 4, which covers the case of Theorem 2, our lower bound for subsystem codes. This also covers the case of Theorem 3, our generalization of [8] to -dimensions.
Theorem (Theorem 4, restated).
For all , there exist constants and such that the following is true: Any -dimensional embedding of a nontrivial subsystem or commuting projector code with must have at least interactions of length at least .
As mentioned after the statement of Lemma 11, the Union Lemma for subsystem codes is substantially weaker than the corresponding result for commuting projector codes. Without the ability to conclude that the union of correctable sets remains correctable, we cannot directly generalize the techniques previously employed in the proofs of the generalized BPT bound, which required alternating applications of the expansion and union lemmas [2, 8]. This poses a challenge for subsystem codes since we only obtain a dressed-cleanable set after the union lemma, and there is no straightforward way to continue with the expansion lemma, which requires correctable sets.
In view of these challenges, we take an alternative approach to the proof of Theorem 4 by repeatedly – and exclusively – applying the expansion lemma to a carefully crafted subset of qubits in order to grow our correctable region. To do this, we grow our correctable region by sweeping across our set of qubits one dimension at a time, changing directions and moving into a new dimension whenever the expansion process in unable to continue in the previous dimensions. The brunt of the proof is showing that this process never gets stuck, and that we are eventually able to grow our correctable set without obstruction to encompass the entire set of qubits . In this way, we are able to bypass the usage of the union lemma altogether.
We point out that the usual way of doing this expansion [7, 6, 8] – starting with a box and repeatedly adding the boundary – does not work for general -dimensional embeddings. For general embeddings, the qubits may not be constrained to an box, so, at some step, the uncontrolled expansion boundaries could contain more than qubits, in which case we cannot apply the expansion lemma. For example, consider qubits embedded in 2-dimensions in a square, with qubits distributed within of the box’s boundary, and the remainder randomly distributed in the square. If we expand a rectangle from anywhere inside the square, applications of the expansion lemma fail when we approach the boundary. The easiest -dimensional embeddings to realize are ones on a lattice structure contained in a box; our general statement shows that more creative embeddings like the one above cannot save on locality.
The general expansion process is quite involved in -dimensions. We refer the reader to Appendix A for an extended exposition of the -dimensional case as an illustration of the basic idea of the proof, as well as the full proof in dimensions.
4 Proof of Theorem 5
Theorem (Theorem 5, restated).
For all , there exist constants and such that the following is true: Any -dimensional embedding of a subsystem code with must have at least interactions of length at least .
First, we state two lemmas that help us find large correctable sets in a -dimensional embedding of a quantum code. The first is a generalization of the “holographic principle” for error correction in [5], which shows that the area, rather than the volume, governs the size of correctable sets. Recall that counts the number of interactions involving qubits in with length at least (see Definition 8).
Lemma 16 (Holographic Principle).
Suppose we have a quantum code (either commuting projector or subsystem) with an embedding , and suppose . Let be the subset of qubits contained in a box with sides of length at most
| (7) |
If , then is correctable.
We refer the reader to [9] for the formal proof.
If we divide into cubes using Lemma 15, most cubes will be “good” in that they contain long-ranged interactions (see footnote of [8]). Lemma 16 then says that all the good cubes are correctable. How do we handle the cubes with large numbers of bad qubits? In [8], the solution was to further subdivide the bad cubes into sufficiently small rectangles, most of which then contains a sufficiently small number of bad qubits. The same strategy works in -dimensions:
Lemma 17 (Subdivision).
Let and be positive real numbers. Let be a finitely supported function. Let be a box, with and . Then there exists a division of by hyperplanes orthogonal to into boxes such that:
-
1.
Each box has dimensions , with .
-
2.
Each satisfies either (i) or (ii) has .
-
3.
The number of boxes is at most .
We refer the reader to [9] for the formal proof.
Finally, we collect a few inequalities that we will frequently use in the proof of Theorems 5 and 6.
Lemma 18.
Let
| (8) |
for some . Suppose that satisfies . Then we have
-
1.
-
2.
-
3.
We are now ready to prove Theorem 5.
Proof of Theorem 5.
We give a proof by contradiction, where we first assume that we have an embedding of a subsystem code with logical qubits that has few long interactions, and then show that the code’s dimension must actually be less than . With hindsight, choose . Note that we have for . Choose . Suppose we have a subsystem code with a -dimensional embedding satisfying . Let
| (9) |
and note that we have , where the first upper bound follows from , and the lower bound from .
Now assume for the sake of contradiction that the embedding has at most interactions of length . Call an interaction long if its length is at least and short otherwise. Call a qubit bad if it participates in a long interaction and good otherwise. Then the function counts the number of long interactions that the qubit participates in. By assumption, there are at most long interactions, so the total number of bad qubits is at most . Now we construct a division of into that outlines the partition of the qubits . Let
| (10) |
as in Lemma 16. It follows from Lemma 18(2) that . Apply Lemma 15 with (and with arbitrary). This produces a tiling of into cubes of side length , where at most qubits of are within distance of some codimension-1 face of some cube. We call a cube good if and bad otherwise. Now apply Lemma 17, with , to decompose each bad cube into boxes . All boxes obtained in this way will also be called bad. This process results in a division of into good cubes and bad boxes. It follows from Lemma 17 (item 3) that the total number of bad boxes is no more than
| (11) |
Now we define the division as follows:
-
is the set of all points within distance of some codimension-1 face of either a good cube or a bad box .
-
is the set of points not in .
Note that we can perturb the tiling slightly in order to ensure that no qubits lie on the boundary of any subregion of or .
Having constructed the division, we will now construct a corresponding partition of qubits such that is dressed-cleanable and . This will give us our desired contradiction from Lemma 12. We define the partition as follows:
-
is the set of all good qubits in region .
-
is the set of all remaining qubits. These are either good qubits in region or bad qubits.
It remains to check that is dressed-cleanable and that . We refer the reader to [9] for the formal proof.
5 Proof of Theorem 6
We now prove Theorem 6, which, together with Theorem 4, yields Theorem 3, our generalization of the main result of [8] to case of -dimensional embeddings.
Theorem (Theorem 6, restated).
For all , there exist constants and such that the following is true: Any -dimensional embedding of a commuting projector code with must have at least interactions of length .
Proof.
For , the result follows from Theorem 4, so it suffices to consider the case where . With hindsight, choose , and let . Note that . Suppose we have a commuting projector code with a -dimensional embedding satisfying . Let
| (12) |
Note that we have , where the lower bound follows from and the first upper bound from the .
Now assume for the sake of contradiction that the embedding has at most interactions of length . Call an interaction long if its length is at least and short otherwise. Call a qubit bad if it participates in a long interaction and good otherwise. The function counts the number of long interactions that the qubit participates in. By assumption, the total number of long interactions is at most , so the total number of bad qubits is at most . We will construct a division of into subsets that will inform the partition of the qubits . Let
| (13) |
as in Lemma 16. Note that it follows from Lemma 18 that and .
Apply Lemma 15 with and with as the multiset where each qubit appears with multiplicity . This gives a partition of into a set of cubes of side length . By construction, at most qubits of are within distance of a codimension-2 face of some cube, and at most bad interactions involve a qubit within distance of a codimension-1 face of some cube. We call a cube good if and bad otherwise. Now apply Lemma 17 to decompose each bad cube into boxes . All boxes obtained by subdividing a bad cube will also be called bad. This process results in a division of into good cubes and bad boxes. By Lemma 17 (item 3), the total number of bad boxes is no more than
| (14) |
Now we define the division as follows:
-
is the set of all points within distance of some codimension-2 face of a good cube or a bad box .
-
is the set of all points not already in and within distance of some codimension-1 face of a good cube or bad box .
-
is the set of all points not already in and within distance of some codimension-1 face of a good cube .
-
is the set of points not in or .
Note that we can perturb the tiling slightly in order to ensure that no qubits lie on the boundary of any subregion of , , , or .
Having defined the division of , we will now construct our partition of qubits . A sketch of the high-level ideas are as follows: We aim to define our qubit partition with the goal of having be correctable, and . This will lead to the desired contradiction using Lemma 13. There are two cases to consider, depending on whether or . When , we have bad qubits, which can then be directly placed in without affecting the requirement that . When , we have bad qubits, and the set of all bad qubits is itself correctable. Our chosen division of implies that very few bad qubits can interact with the qubits in , so the union lemma suggests that we can add almost all of the bad qubits to while preserving its correctability. We now continue with our proof, divided into the two cases and .
Case 1: .
We define the partition of qubits as follows:
-
is the set of qubits in region , along with all bad qubits.
-
is the set of all good qubits in region
-
is the set of all good qubits in region .
It’s clear that this is indeed a partition of . It remains to show that are correctable, and that . This gives us a contradiction with the fact that and are correctable through Lemma 13. We refer the reader to [9] for the formal proof.
Case 2: .
From equation (13), the total number of bad boxes is at most , which is less than . It follows that there are no bad boxes in this case, only good cubes. We define the partition of qubits in this case as follows:
-
consists of the set of qubits in region , together with all qubits participating in a long interaction with a qubit in (including the bad qubits in .
-
is the set of good qubits in region , together with the bad qubits not in .
-
is the set of good qubits in region .
It’s clear that this is a partition of the qubits in . It remains to check that are correctable and . This gives us our desired contradiction using Lemma 13. We refer the reader to [9] for the formal proof.
We have obtained a contradiction in both the and cases, and this completes the proof of the theorem.
6 Construction for Upper Bounds
The bounds derived in Theorems 2 and 3 are tight in both the interaction count and the interaction length . Tightness is shown by constructing explicit examples of embedded codes which saturate the interaction count or length. For the interaction count, it suffices to consider an asymptotically good quantum low-density parity-check (qLDPC) code [14, 12], which has interactions of any length. Since a stabilizer code can also be regarded as a subsystem code with zero gauge qubits, this shows that both Theorem 2 and 3 are tight in terms of interaction count. This is covered by Theorem 1.3 of [8].
We now describe constructions that show the interaction length is optimal in Theorem 2 and Theorem 3. In both cases, we construct a code that saturates the bound for interaction length by concatenating an asymptotically good qLDPC code with a geometrically local code which saturates the Bravyi and BPT bounds, respectively.
6.1 Subsystem codes
We start by showing the interaction length for subsystem codes (Theorem 2) is optimal. We will define a concatenated subsystem code composed of an asymptotically good qLDPC code, together with a subsystem code which is geometrically local in -dimensions and saturates the Bravyi bound. For the local subsystem code, we employ the “wire code” construction of Baspin and Williamson [4].
Theorem 19 (Wire code [4]).
For all , there exists an such that, for all positive integers there exists a subsystsem code with parameters that has a set of gauge generators that are -local in a -dimensional embedding.
The concatenation procedure for subsystem codes is formally identical to the process for stabilizer codes. Namely, if and are subsystem codes, then their concatenation is defined using blocks of the inner code and copies of the outer code . Let be the th logical qubit of the th block. Then the concatenated code is defined by replacing the th physical qubit of the th block with .
Lemma 20 (Concatenated Subsystem Codes).
Let and be two subsystem codes. Then there exists a subsystem code , called the concatenation of and
Theorems 19 and 20 together give the desired construction. We state the result below and refer the reader to [9] for the formal proof.
Theorem 21 (Optimality of Interaction Length for Subsystem Codes).
For all , there exists a constant such that the following holds: for all with satisfying or , there exists an subsystem code with a -dimensional embedding containing no interactions of length at least
| (15) |
6.2 Commuting Projector Codes
We now show the interaction length in Theorem 3 is optimal. The construction is very similar to the one used in Theorem 1.3 of [8], except generalized to -dimensions. In 2D, the surface code offers a simple and natural candidate for a geometrically local code that saturates the BPT bound. In higher dimensions, we instead use the family of “subdivided codes” constructed by Lin, Wills and Hsieh [13].
Theorem 22 (Subdivided code [13]).
For all , there exists an such that, for all positive integers there exists a stabilizer code with parameters that has a set of stabilizer generators that are -local in a -dimensional embedding.
The optimality of the interaction length follows by concatenating a good qLDPC code with the subdivided code. We refer the reader to [9] for the formal proof.
Theorem 23 (Optimality of Interaction Length for Stabilizer Codes).
For all , there exists a constant such that the following holds: for all with satisfying either or , there exists a quantum stabilizer code with a -dimensional embedding containing no interactions of length at least
| (16) |
References
- [1] Nouédyn Baspin, Venkatesan Guruswami, Anirudh Krishna, and Ray Li. Improved rate-distance trade-offs for quantum codes with restricted connectivity. Quantum Science and Technology, 10(1):015021, 2024.
- [2] Nouédyn Baspin and Anirudh Krishna. Connectivity constrains quantum codes. Quantum, 6:711, 2022.
- [3] Nouédyn Baspin and Anirudh Krishna. Quantifying nonlocality: How outperforming local quantum codes is expensive. Physical Review Letters, 129(5):050505, 2022.
- [4] Nouédyn Baspin and Dominic Williamson. Wire codes. arXiv preprint arXiv:2410.10194, 2024.
- [5] Sergey Bravyi. Subsystem codes with spatially local generators. Physical Review A, 83(1), January 2011. doi:10.1103/physreva.83.012320.
- [6] Sergey Bravyi, David Poulin, and Barbara Terhal. Tradeoffs for reliable quantum information storage in 2D systems. Physical Review Letters, 104(5):050503, 2010. doi:10.1103/PhysRevLett.104.050503.
- [7] Sergey Bravyi and Barbara Terhal. A no-go theorem for a two-dimensional self-correcting quantum memory based on stabilizer codes. New Journal of Physics, 11(4):043029, 2009. doi:10.1088/1367-2630/11/4/043029.
- [8] Samuel Dai and Ray Li. Locality vs quantum codes. In Proceedings of the 57th Annual ACM Symposium on Theory of Computing, pages 677–688, 2025.
- [9] Samuel Dai, Ray Li, and Eugene Tang. Optimal locality and parameter tradeoffs for subsystem codes. arXiv preprint arXiv:2503.22651, 2025.
- [10] Jeongwan Haah and John Preskill. Logical-operator tradeoff for local quantum codes. Physical Review A, 86(3), September 2012. doi:10.1103/physreva.86.032308.
- [11] Yifan Hong, Matteo Marinelli, Adam M Kaufman, and Andrew Lucas. Long-range-enhanced surface codes. Physical Review A, 110(2):022607, 2024.
- [12] Anthony Leverrier and Gilles Zémor. Quantum tanner codes. In 2022 IEEE 63rd Annual Symposium on Foundations of Computer Science (FOCS), pages 872–883. IEEE, 2022.
- [13] Xingjian Li, Ting-Chun Lin, and Min-Hsiu Hsieh. Transform arbitrary good quantum ldpc codes into good geometrically local codes in any dimension. arXiv preprint arXiv:2408.01769, 2024.
- [14] Pavel Panteleev and Gleb Kalachev. Asymptotically good quantum and locally testable classical ldpc codes. In Proceedings of the 54th Annual ACM SIGACT Symposium on Theory of Computing, pages 375–388, 2022.
- [15] Fernando Pastawski and Beni Yoshida. Fault-tolerant logical gates in quantum error-correcting codes. Physical Review A, 91(1), January 2015. doi:10.1103/physreva.91.012305.
Appendix A Proof of Theorem 4
In this appendix, we first give a detailed sketch of the proof of Theorem 4 for the case of -dimensional embeddings. This is meant as a simplified illustration of the proof idea in the general -dimensional case, which may be difficult to visualize. We then give the full proof in -dimensions.
A.1 Detailed Sketch of Theorem 4 in -dimensions
Let be a -dimensional embedding of a subsystem code satisfying . Without loss of generality, we may assume that all of our qubits are contained in the interior of a large square , for some integer . We remove a border of width so that we do not have to worry about edge cases later in our proof. Suppose for the sake of contradiction that there exists at most interactions of length at least . Note that our choice of code parameters ensures that we have . We will call any qubit participating in a length interaction a bad qubit. Let be the set of all bad qubits. Then by assumption, . Given any region , we will say that is correctable if and only if is correctable.
The basic idea of the proof is as follows. We wish to show that, given our assumption on the number of long interactions, a small correctable region can be iteratively grown without bound using the expansion lemma. Eventually the correctable region will encompass the entire set of qubits , which is a contradiction with our initial assumption that the code is non-trivial. We do this by first expanding along the -direction, and then switching to the -direction whenever we are unable to continue in the -direction. The details for the two cases are given below.
A.1.1 Expansion in the -direction
Let us imagine starting with a region of the form of a vertical strip , for some . If , then contains no qubits by assumption, so it is vacuously correctable. Now, given an existing correctable region of the form , we wish to apply the expansion lemma to obtain a larger correctable set of the form . This will be possible provided that the number of qubits in the boundary of is sufficiently small so that the boundary set itself is correctable. We will formalize this requirement by saying that a number is “good” if the density of qubits around the line is low. Formally, is a good -coordinate if the set contains at most qubits, and bad otherwise.
The boundary of consists of all qubits within a distance of the line , together with a subset of the bad qubits. Therefore the boundary is a subset of . If is good, then by definition this subset contains at most
| (17) |
qubits, and is hence correctable. It follows by expansion and subset closure that if is correctable and is good, then is also correctable. This gives us an easy way to grow the sets . However, this process cannot continue indefinitely, since there is no guarantee at each step that the new coordinate is good. When is a bad coordinate, our expansion process gets stuck. To get unstuck, we will fill in the stretch around the bad coordinate by expanding in the -direction. After this gap containing bad -coordinates has been filled, we can continue expanding in the -direction until we reach our next obstacle.
A.1.2 Stuck in the -direction, expand along the -direction
Now we formalize the process of expanding in the direction. Given a bad coordinate , we will define to be the “next available” good coordinate. More precisely, we define
| (18) |
where is the set of all good coordinates larger than , and is a sufficiently small value so that we actually have .222The small constant is necessary since the set of good coordinates is an open set, and as such does not contain its own infimum. A bit of thought reveals that it is sufficient to take smaller than the minimum element of , where denote the -coordinates of qubits . Given a set where is good but is bad, let us define to be
| (19) |
We will call sets defined this way legal sets. Our goal is to show that given a correctable legal set , we can always apply expansion in the -direction to obtain a new correctable legal set .
The key observation now is that the additional block in must be thin in the -direction. Indeed, the entire interval consists of bad coordinates. Any strip of width centered around a bad coordinate contains at least qubits, and since we only have a total of qubits, the set can fit at most such strips inside. It follows that we have
| (20) |
which implies
| (21) |
Now, consider the boundary of a correctable legal set . This will be a subset of
| (22) |
Since and are good coordinates, we have
| (23) |
by assumption. By Lemma 14, the number of qubits in the subset is bounded above by
| (24) |
Therefore the boundary of contains at most
| (25) |
qubits, and is hence correctable. It follows by expansion and subset closure that if is a correctable legal set, then is again a correctable legal set. We can therefore continue expanding in the -direction until we reach . This is a vertical strip with a good boundary coordinate . We can therefore return to the previous case and proceed to expand along the -direction again. This process can now continue indefinitely, alternating between the and -directions whenever we get stuck again. In this way, starting from an initial correctable set, say the vacuously correctable region , we can iteratively grow our correctable region without bound to encompass the entire set of qubits . Thus we arrive at our desired contradiction.
A.2 Proof of Theorem 4 in -dimensions
For notational convenience, we grow the correctable region from low coordinates to high coordinates for this proof. For a set , we write .
Proof.
With hindsight, set . Suppose are code parameters with . With hindsight, choose
| (26) |
so that . Let be a -dimensional embedding of a subsystem code with , and suppose there are at most interactions of length at least .
Let denote the set of qubits participating in long range interactions, so that . Without loss of generality, we may assume all the qubits are in the box for some large integer . Choose a sufficiently small constant . With hindsight, less than the minimum nonzero element of suffices.
For , call real number -good if has at most qubits and -bad otherwise. By convention, we will consider every real number to be -good when . An -bad number represents an -th-coordinate-value where we would “get stuck” and need to start expanding in a different direction.
For and an -bad real number , let be the maximum value such that all values in the interval are -bad ( is undefined if is -good). Note, as is sufficiently small, that is always -good when it is defined.
For , with , let
| (27) |
Call such a set legal if (i) is -good for all and (ii) is -bad for . We grow a large correctable set of the above form using the following four properties:
-
1.
(If possible, expand in th dimension): If , the set is correctable and legal, and is legal, then is correctable.
We apply the expansion lemma. Note that the boundary is a subset of
(28) Since is legal, the values and are -good for and , respectively. By definition of -good, each set in the above union, other than , has at most qubits. Thus, has at most qubits, so is correctable. It follows that is correctable, and by Subset Closure, is correctable.
-
2.
(Stuck in -th dimension, start in -th-dimension): If is correctable and legal, and is not legal, then is correctable and legal.
The set is correctable by definition as . It is legal also by definition, as we assume is -good but is -bad, and 0 is trivially -good.
-
3.
(Expand in -th dimension): If is correctable and legal, then is correctable and legal.
It is legal as every real number is -good by definition. For correctable, we again use the expansion lemma. Following part 1, the boundary is a subset of
(29) As in part 1, we have , and all but the last set in the union above has size at most . We now bound the size of the last set in . Since is -bad for all , a counting argument yields
(30) To see this, pack strips of width in the th dimension into . Each strip has at least qubits by definition of being -bad. There are at most qubits, so there are at most packed strips, so the total width satisfies
(31) We conclude . Hence, the last box has at most
(32) qubits inside by Lemma 14. The total boundary thus has at most
(33) qubits. It follows that is correctable, so is correctable, and by Subset Closure, is correctable.
-
4.
(Finish -th-dimension, get unstuck in -th dimension): If is correctable and legal, and , then is correctable.
The set is correctable because equals , which equals . It is legal because is not -bad by definition of .
We can repeatedly apply these properties to get that the set of all qubits is correctable by induction. Here are the details. Let be the enumeration of the tuples in , in lexicographical order. Define the lexicographical index of a region as the largest such that is lexicographically less than or equal to . We prove by induction that, for all , there exists a correctable and legal set with lexicographical index at least . For the base case, is clearly correctable and legal. For the induction step, suppose we have a correctable and legal set with lexicographical index . The above items shows that we can find a region with strictly larger lexicographical index: If , either , in which case we are done, or and we apply item 4 – the lexicographical index increases because . Otherwise, if , we apply item 3. Otherwise, if is legal, we apply item 1, and if not, we apply item 2. This completes the induction.
Since the entire set of qubits is correctable, an application of the AB Lemma (12) with and implies that . This contradicts our assumption that the code is nontrivial.
