Locality vs Quantum Codes

• Locality vs quantum codes are a class of quantum error-correcting codes that balance robust error protection with the physical limitations of local qubit interactions.
• Recent research quantifies trade-offs, establishing bounds like the BPT limit in 2D systems and extending these constraints to higher-dimensional and LDPC codes.
• Innovative constructions such as hierarchical, concatenated, and locally recoverable codes offer actionable insights for reconciling physical locality with improved quantum code performance.

Locality versus Quantum Codes

Quantum error-correcting codes, especially those intended for scalable quantum computing and storage, must balance the algebraic demands of robustness (distance, rate) against acute constraints on physical or interaction locality. This trade-off is sharply distinct from the classical regime and is governed by a set of quantitative and qualitative limitations inherent to quantum information, many of which have only recently been rigorously characterized. The interplay between locality (geometric or logical), code parameters, and the structure of quantum codes is now a central theme traversing the theory and practice of @@@@1@@@@.

1. Modeling Locality in Quantum Codes

Quantum code locality refers to restrictions on the support of stabilizer generators (or more generally, code checks), locality of recovery operations, and geometric layout of qubits and couplings. The definition is context-dependent:

• Geometric locality: Each code generator (stabilizer or gauge) acts nontrivially only on qubits situated within a bounded spatial region, e.g., adjacent qubits on a 2D or 3D lattice (Haah et al., 2010, Lin et al., 2023).
• Logical locality (LDPC): Each check acts on at most $w=O(1)$ qubits, and each qubit participates in at most $O(1)$ checks ("quantum LDPC") (Leverrier et al., 2022, Baspin et al., 2021).
• Local recovery: For locally recoverable codes (qLRCs), a single-qubit erasure can be corrected by operations on some constant number $r$ of surrounding qubits (Sharma et al., 2024, Golowich et al., 2023).

The notion of interaction length is made precise when codes are embedded into low-dimensional space: e.g., a planar code has only short-range (local) interactions, whereas quantum LDPC codes with distance scaling faster than $n^{1/2}$ necessarily require long-range checks as quantified below (Dai et al., 2024, Baspin et al., 2021).

2. Fundamental Locality–Parameter Trade-offs

Geometric and logical locality impose hard constraints on the achievable code parameters—dimension $k$, distance $d$, and block length $n$—in quantum codes.

• Bravyi–Poulin–Terhal (BPT) Bound: Any 2D-local stabilizer code with $n$ physical qubits, $k$ logical qubits, and distance $d$ must satisfy

$k d^2 \leq O(n)$

This cannot be violated by codes whose stabilizers are strictly geometrically local in 2D (Haah et al., 2010, Dai et al., 2024).

• Higher-dimensional generalization: For codes local in $D$ dimensions, optimal codes satisfy

$$d = O\left(n^{(D-1)/D}\right), \quad k = O\left(n^{(D-2)/D}\right)$$

and the energy barrier scales as $E = O\left(n^{(D-2)/D}\right)$ (Lin et al., 2023).

• Logical operator weight–distance trade-off: For any $D$-dimensional code, the minimal support $\tilde d$ of a logical operator and code distance $d$ satisfy

$\tilde{d} \cdot d^{1/(D-1)} = O(n)$

which severely limits self-correction in low dimensions (Haah et al., 2010).

• Quantum LDPC with rate/distance above local bounds: Good quantum LDPC codes ($k,d = \Omega(n)$, $w=O(1)$) are impossible with strictly local interactions in 2D or 3D (Baspin et al., 2021, Eldar et al., 2016, Dai et al., 2024).
• Impossibility of local correctability: In contrast to classical LCCs, quantum codes cannot allow more than one disjoint recovery set per qubit, due to the no-cloning property (Golowich et al., 2023).

3. Quantitative Locality vs Code Parameters: Recent Optimal Bounds

Recent results have fully characterized the penalties for exceeding locality-imposed thresholds:

• Sharp lower bounds on non-locality (Dai et al., 2024): For a quantum stabilizer code embedded in 2D, if $kd^2 > c n$ for some constant $c$, then:
  • At least $\Omega(\max(k,d))$ interactions (edges in the interaction graph) must have length at least

  $$\ell^* = \max\left(\frac{d}{\sqrt{n}}, \left(\frac{kd^2}{n}\right)^{1/4}\right)$$

  This quantifies the required number and length of long-range checks to breach the BPT regime. - These bounds are tight, being matched by (i) truncated/padded good quantum LDPC codes for count, and (ii) concatenated codes with surface codes for length.

• Stacked architectures and beyond: In physical architectures admitting only a small number of very long-range links (e.g., "stacked codes"), the best achievable code distances and rates are still polynomially bounded away from the LDPC optimum and are quantitatively ruled out for families like hypergraph product and balanced product codes (Dai et al., 2024, Baspin et al., 2021).

4. Local Testability, Expansion, and the Quantum–Classical Contrast

Local testability—the ability to detect proximity to the code space by checking a constant-sized random subset of constraints—depends critically on the interaction graph structure:

• Quantum Locally Testable Codes (qLTCs):

  • Defined via a soundness function $R(\delta)$, giving the probability a random check is violated as a function of distance $\delta$ to the code (Aharonov et al., 2013).
  • Unlike the classical case, strong small-set expansion in the interaction graph decreases qLTC soundness: $R(\delta) \leq O(\varepsilon) k\delta$ when the graph is a $\varepsilon$-expander, due to monogamy-of-entanglement—each qudit cannot fail many checks simultaneously. This is the opposite of the classical LTC situation, where expansion boosts soundness.
  • Even in the "worst" topologies, quantum codes exhibit an "alphabet gap" $r(\delta) \leq 1 - 1/d^2$ (where $d$ is the qudit dimension), and a further quantum gap $<1$ for $k \geq 4$ due to monogamy effects (Aharonov et al., 2013).
• Quantum PCP and PCPP reductions: Quantum analogues of PCP-of-proximity imply a direct reduction from quantum PCPs to qLTCs in the stabilizer setting, but this bridge remains open for general non-commuting Hamiltonians (Aharonov et al., 2013).
• Discrepancy and expansion: Merely having a "random-like" high-dimensional expander topology (small discrepancy) is insufficient for linear-distance quantum LDPC codes; additional algebraic structure is necessary, in sharp contrast to the classical expander code paradigm (Eldar et al., 2016).

5. Constructing Quantum Codes under Locality and Connectivity Constraints

Various architecturally relevant strategies have been developed to approach the locality–performance barrier:

• Quantum LDPC (graph-theoretic approach): The code's connectivity graph (vertices: qubits; edges: support-overlaps of stabilizers) governs the achievable trade-off.
  • If all separators in the connectivity graph are sublinear, then $d=O($separator$)$; to have both linear $k$ and $d$ requires the code's graph to be an expander (Baspin et al., 2021).
  • Codes local in $D$-dimensional Euclidean or hyperbolic space achieve at best $d=O(n^{1-1/D})$, with similar rate constraints.
• Codes from subdivision: Recent constructions subdivide the square-complex structure of explicit good qLDPC codes and embed the subdivision into $\mathbb{R}^D$, saturating BPT-style locality–distance–rate bounds up to (removable) polylog factors, and with matching energy barriers (Lin et al., 2023).
• Bivariate bicycle, trivariate bicycle, and small LDPC codes: Hybrid designs balance locality and overhead, yielding codes with weight-4 or weight-6 checks, moderate-range couplers, and substantial improvement over 2D-local surface codes for moderate code sizes (Andersen et al., 13 Jul 2025, Berthusen et al., 2024).
• Hierarchical or concatenated architectures: To reconcile geometric locality with scalability (threshold), one concatenates a good quantum LDPC code (as outer code) with a log-length inner surface code, producing "hierarchical" codes: $K = \Omega(N/\log^2 N)$ logical bits, $D(N) = \Omega(N^{\delta}/\log^{2\delta} N)$ distance, with constant-depth local circuits and superpolynomial error reduction below threshold (Pattison et al., 2023).
• Quantum locally recoverable codes (qLRCs): Constructions based on good polynomials or Tamo–Barg structures give CSS codes with optimal quantum Singleton-like bound trade-offs among dimension, distance, and locality for any block length and local repair parameter $r$, with efficient decoding and, in the folded variant, practical spatial locality (Sharma et al., 2024, Golowich et al., 2023).

6. Extensions: Energy Barriers, Logical Operators, and Fault-Tolerance

• Logical Operator Geometry and Energy Barriers: Locality constrains not just code distance, but also the shape and minimal support of logical operators, and hence the code’s thermal stability:
  • In 2D, all codes with geometric locality admit string-like logical operators; the maximal energy barrier is $O(1)$ and self-correction is impossible (Haah et al., 2010).
  • 3D codes with strictly local cube stabilizers can be constructed to forbid all string logical operators (Haah codes and variants with $p \geq 5$), but the energy barrier grows only logarithmically with system size due to forced "fractal" error structures (Kim, 2012).
• Locality-preserving logical operators: In $d$-dimensional topological codes, gates that preserve locality (support expands by at most constant thickness) are constrained to lie in the $d$th level of the Clifford hierarchy (Webster et al., 2017). Stacked surface codes admit full Clifford LPLOs in 2D, and CCZ (non-Clifford) LPLOs in 3D.
• Sublinear-weight parity-checks and transversal non-Clifford gates: Subsystem code product constructions now achieve $[[N,\Theta(N),\Theta(N)]], w = O(N^\varepsilon)$ for any fixed $\varepsilon > 0$ and support transversal CCZ gates; efficient multivariate-Prony decoders make these codes practically fault-tolerant despite sublinear locality (Golowich et al., 8 Oct 2025). This resolves longstanding conjectures on the existence and structure of such codes.

7. Implications and Open Questions

The quantum locality–code parameter landscape displays a series of fundamental differences from the classical case:

• Local constraints that boost soundness, testability, and code performance in classical setting are, due to quantum entanglement restrictions, often detrimental or strongly limiting for quantum codes.
• Even high-dimensional expansion or random-like geometry is insufficient; algebraic constructions with tailored (often non-expander) structure are essential to achieve good parameter regimes.
• There is a sharp, quantifiable resource cost to exceeding 2D-locality-imposed bounds, both in the number and length of long-range interactions needed, and in the necessity of abandoning geometric or hardware-friendly layouts for high-performance codes.
• For scalable quantum error correction, architecture-aware code design—trading between locality, overhead, and implementable syndrome extraction—is indispensable.

Open problems include the existence of qLTCs matching classical LTCs in all parameters, further clarifying the quantum PCP/qLTC/NLTS relationships, and the construction of truly self-correcting quantum memories with locality restrictions (Aharonov et al., 2013, Sharma et al., 2024, Eldar et al., 2016).