Layer codes

Abstract

Quantum computers require memories that are capable of storing quantum information reliably for long periods of time. The surface code is a two-dimensional quantum memory with code parameters that scale optimally with the number of physical qubits, under the constraint of two-dimensional locality. In three spatial dimensions an analogous simple yet optimal code was not previously known. Here we present a family of three dimensional topological codes with optimal scaling code parameters and a polynomial energy barrier. Our codes are based on a construction that takes in a stabilizer code and outputs a three-dimensional topological code with related code parameters. The output codes are topological defect networks formed by layers of surface code joined along one-dimensional junctions, with a maximum stabilizer check weight of six. When the input is a family of good quantum low-density parity-check codes the output codes have optimal scaling. Our results uncover strongly-correlated states of quantum matter that are capable of storing quantum information with the strongest possible protection from errors that is achievable in three dimensions.

Quantum error correcting codes are inefficient when implemented on platforms with local connectivity in two dimensions, which motivates platforms with 3D connectivity and codes applicable in these conditions. Here, the authors show how to transform any CSS stabilizer code into a 3D topological code, leading to codes with optimal asymptotic scaling in 3D.

Introduction

Quantum computing promises to open a new window into highly-entangled quantum many-body physics^1–5. Quantum error correction is a crucial ingredient in the design of scalable quantum computers that aim to access new regimes of physics beyond the reach of classical simulations^6–14. Topological quantum codes form the basis of leading approaches to implement quantum error correction^15–22. This can be attributed to their favorable properties, including relatively simple stabilizer checks and high thresholds. Topological codes form an important subclass of low-density parity check (LDPC) codes^23–26, set apart by the geometric locality of their checks.

The surface code is the simplest example of a topological code and as such is the most widely studied quantum error-correcting code both theoretically and experimentally^15–22. It is known by several names including the toric code, the planar code, ${\mathbb{Z}}_2$ lattice gauge theory, the ${\mathbb{Z}}_2$ quantum double, and $\mathcal{Z}\left({\text{Vec}}_{{\mathbb{Z}}_2}\right)$^{15,16,27–29}. Despite its popularity and positive features, the surface code is far from attaining optimal scaling of its code parameters [[n, k, d]]. Here n is the number of physical qubits, k is the number of encoded qubits, and d is the code distance, i.e. the minimum weight of a nontrivial logical operator. The surface code is a [[2L(L − 1), 1, L]] code and hence has a vanishing rate $\frac{k}{n}$ and suboptimal distance scaling when compared to general LDPC stabilizer codes which can achieve a constant $\frac{d}{n}$ scaling. In a recent breakthrough, good LDPC codes were discovered³⁰ that attain code parameters with optimal scaling i.e. [[n, Θ(n), Θ(n)]] which has been a subject of much interest^31–37.

Topological codes defined on a regular lattice in D-dimensional Euclidean (flat) space with a finite density of qudits can never attain optimal scaling of the code parameters. This is because they are constrained by several bounds, including the Bravyi-Poulin-Terhal (BPT) bound³⁸

$$k{d}^{\frac{2}{D-1}}\le O\left(n\right),$$ 1

the Bravyi-Terhal (BT) bound³⁹

$$\begin{array}{c}\hfill d\le O\left(n^{\frac{D-1}{D}}\right),\end{array}$$ 2

and Haah’s bound⁴⁰

$$\begin{array}{c}\hfill k\le O\left(n^{\frac{D-2}{D}}\right).\end{array}$$ 3

In light of these bounds, the best scaling of code parameters for a topological code in D dimensions one can hope to achieve is $\left[\left[n,\mathrm{\Theta }\left(n^{\frac{D-2}{D}}\right),\mathrm{\Theta }\left(n^{\frac{D-1}{D}}\right)\right]\right]$. Writing these code parameters in terms of the linear extent of a hypercuboid lattice L we find [[Θ(L^D), Θ(L^D−2), Θ(L^D−1)]]. The most physically relevant cases are D = 2, 3. It is apparent from the parameters given above that the surface code achieves optimal scaling for D = 2. Here, we introduce families of layer codes that achieve optimal scaling for D = 3.

Results

In this work, we introduce a construction that takes as input an arbitrary Calderbank-Shor-Steane^41,42 (CSS) stabilizer code and outputs a topological CSS code that is local in dimension D = 3 which we call a layer code. The code parameters of the input and output codes of our construction are related by

$$\begin{array}{c}\hfill \left[\left[n,k,d\right]\right]\mapsto \left[\left[\mathrm{\Theta }\left(n{n}_X{n}_Z\right),k,\mathrm{\Omega }\left(\frac{d}{w}n*\right)\right]\right],\end{array}$$ 4

where n_X is the number of X checks, n_Z is the number of Z checks, $n*=\min \left(n_X,n_Z\right)$, and w is the maximum weight of the checks in the input code. Furthermore, the maximum check weight of the output code is 6. The stabilizer checks that define the layer codes are presented explicitly in Supplementary Note V.

The layer codes output by our construction have additional structure, taking the form of topological defect networks^43–45. More specifically, each layer code is constructed from layers of surface code with one layer for each physical qubit, X check, and Z check of the input code. The surface code layers associated to physical qubits are stacked on xz planes of a cubic lattice, the layers associated to X checks are stacked on xy planes, and the layers associated to Z checks are stacked on yz planes. The grid of surface code layers are then coupled together at nontrivial junctions that are determined by the Tanner graph of the input code.

When applied to a family of good CSS LDPC codes our construction outputs a family of topological CSS codes that achieve optimal scaling of the code parameters for D = 3, that is

$$\left[\left[n,\mathrm{\Theta }\left(n\right),\mathrm{\Theta }\left(n\right)\right]\right]\mapsto \left[\left[\mathrm{\Theta }\left(n^3\right),\mathrm{\Theta }\left(n\right),\mathrm{\Theta }\left(n^2\right)\right]\right].$$ 5

These code parameters achieve the point a depicted in Fig. 1. Furthermore, the range of code parameters on the line between a and (0, 1) in Fig. 1 can be achieved by tiling layer code blocks. To demonstrate this we parametrize the line from a to (0, 1) by α ∈ [0, 1] and consider N^1−α layer code blocks of size N^α to obtain codes with parameters [[N, Ω(N^1−α ⋅ N^α/3), Ω(N^2α/3)]]. This construction saturates the BPT bound for all attainable values of d. We remark that a union of disjoint layer code blocks ceases to be topological in the sense required for Haah’s bound to apply. Nonetheless, each single block of layer code obeys Haah’s bound and can saturate it. The saturation of the above bounds demonstrates that topological codes are, in a sense, optimal local codes in 3D.

Fig. 1. An illustration of existing bounds on local codes in 3D, and constructions known to saturate them.

The blue shaded area corresponds to the BPT bound³⁸kd≤O(n), and the BT bound³⁹d ≤ O(n^2/3). The point labeled a indicates the layer code construction, see Theorem 1. The red shaded area corresponds to Bravyi’s bounds for subsystem codes⁴⁷. The point b indicates the construction in ref. ⁴⁸. The green shaded area corresponds to the bound on classical codes from ref. ³⁸. The point c indicates the construction in ref. ⁴⁹. All points along the dashed line from a to (1, 0) can be achieved by tiling smaller layer code blocks, see Corollary 1, and similarly for points b and c.

The layer code construction also preserves the scaling of the energy barrier when the input code is LDPC. Here the energy barrier refers to the minimum energy that must be created to implement a nontrivial logical operator by applying a sequence of local operators. We show that a family of good CSS LDPC codes from ref. ³⁶ has energy barrier Θ(n). This leads to our main result.

Theorem 1

There exist families of topological CSS stabilizer codes in D = 3 spatial dimensions that achieve the optimal code parameters [[Θ(L³), Θ(L), Θ(L²)]] and a Θ(L) energy barrier. In particular, layer codes based on the good LDPC codes from ref. ³⁶ achieve these properties and have checks of weight 6 or less.

Proof

The proof is divided into a high level description of the code properties in the “Methods” section, supported by technical lemmas in Supplementary Note IV and an explicit construction of lattice checks in Supplementary Note V.

In section “Code parameters” we explain how the code parameters of the layer codes are related to those of the input codes. This is summarized in Eq. (4). In section “Energy barrier” we explain how the scaling of the energy barrier for a layer code is related to the energy barrier of the input code. In Supplementary Note IV, we present technical lemmas characterizing the form of the logical operators in the layer codes. We rely upon this characterization to establish the scaling of the distance, number of encoded qubits and energy barrier. We show that the family of good CSS LDPC codes from ref. ³⁶ has energy barrier Θ(n). Finally, we introduce a lattice model for the layer codes involving local stabilizer generators of weight at most 6. Together, these results demonstrate that applying the layer code construction to the codes from ref. ³⁶ produces families of layer codes with the claimed properties.

Corollary 1

There exist families of local CSS stabilizer codes in D=3 spatial dimensions that achieve code parameters [[N, Ω(N^1−α ⋅ N^α/3), Ω(N^2α/3)]] for α ∈ [0, 1].

Proof

Consider N^1−α blocks of size N^α each containing a layer code based on the good LDPC codes from ref. ³⁶. The layer code in each block has code parameters [[N^α, Ω(N^α/3), Ω(N^2α/3)]] and checks of weight 6 or less. Since there are N^1−α such code blocks, the stated result follows.

The layer code construction opens the door to a vast, unexplored landscape of promising non translation-invariant topological codes with striking features. Table 1 provides a summary of the input and output codes involved in the construction.

Table 1.

Summary of the input and output code properties in the layer code construction

Input code	Output layer code
General CSS stabilizer code	3D topological defect network code
Physical qubit	xz surface code layer
X check	xy surface code layer
Z check	yz surface code layer
Max check weight w	Max check weight 6
Energy barrier Δ(n)	Energy barrier $\frac{1}{w{w}^{\prime }}\mathrm{\Delta }\left(n\right)$
[[n, k, d]]	$\left[\left[\mathrm{\Theta }\left(n{n}_X{n}_Z\right),k,\mathrm{\Omega }\left(\frac{1}{w}d\min \left(n_X,n_Z\right)\right)\right]\right]$

The variables referenced in this table are defined in the main text.

Examples

We now illustrate our construction with the layer codes that are output given two simple examples of input CSS codes.

Repetition code

The first example is based on the 3 qubit repitition code, which has stabilizer checks ZZI, IZZ. The layer code derived from the 3 qubit repetition code involves 5 surface code layers in total. There are 3 xz surface code layers corresponding to the input physical qubits, and 2 yz surface code layers corresponding to the input code Z checks. Trijunction topological defects join the check layers to the qubit layers as shown in Fig. 2 above.

Fig. 2. The layer code based on the 3 qubit repetition code.

3 gray xz-layers depict surface codes corresponding to input physical qubits. 2 red yz-layers depict surface codes corresponding to input Z checks. Trijunctions between the red and gray layers correspond to nontrivial topological defects. The dashed blue line depicts a logical operator.

Shor’s code

Shor’s code has the following stabilizer checks⁶ X₁X₂X₃X₄X₅X₆, X₄X₅X₆X₇X₈X₉, Z₁Z₂, Z₂Z₃, Z₄Z₅, Z₅Z₆, Z₇Z₈, Z₈Z₉. The layer code based on Shor’s code involves 17 surface code layers in total, 9 xz-layers corresponding to encoded qubits, 2 xy-layers corresponding to X checks, and 6 yz-layers corresponding to Z checks. These surface code layers are joined together at their junctions by defects that follow the incidence relations of the qubits and checks in Shor’s code, see Fig. 3.

Fig. 3. The layer code based on Shor’s code.

9 gray xz-layers depict surface codes corresponding to input physical qubits. 2 blue xy-layers depict surface codes corresponding to input X checks. 6 red yz-layers depict surface codes corresponding to input Z checks. Blue, red, and green junction lines where the layers meet correspond to nontrivial topological defects.

Discussion

In summary, we introduce a family of quantum codes which achieve the parameters [[Θ(n³), Θ(n), Θ(n²)]] and a Θ(n) energy barrier. These parameters are optimal for three-dimensional topological codes. Our codes come with interesting questions about their properties, most significant is whether they are self-correcting quantum memories and how best to decode them. From a condensed matter theory point of view, the most interesting question is how these strongly-correlated states of quantum matter fit into existing classifications of phases. Finally, our construction can be applied to general CSS codes that are not necessarily LDPC. In this work, we only guarantee favorable scaling of the output code’s distance when the maximum stabilizer weight of the input code is constant. Extending this result beyond LDPC codes is an interesting challenge.

Methods

The layer code construction is based on the observation that concatenating an [[n, Θ(n), Θ(n)]] good CSS code with the [[Θ(n²), 1, Θ(n)]] surface code produces a CSS code with parameters [[Θ(n³), Θ(n), Θ(n²)]]. These code parameters have the same scaling behavior as the optimal code parameters for a three-dimensional topological code. However, the concatenated code has stabilizers that are both high weight and nonlocal. We use an extension of lattice surgery⁴⁶ to implement the concatenated code via local checks in three dimensions. We call the resulting codes layer codes.

Construction

We now describe the layer codes at a high level using the formalism of topological defect networks⁴⁴. Relevant background on topological defects is reviewed in Supplementary Note II. A lattice implementation is also detailed in Supplementary Note V. To describe the layer code based on an input CSS code we first specify a numbering of the qubits q_i where i = 1, …, n , X-checks $S_j^X$ where j = 1, …, n_X, and Z-checks $S_k^Z$ where k = 1, …, n_Z. We consider an n_X × n × n_Z cuboid region that contains (n_X + n + n_Z) layers of surface code stacked on lattice planes. There is a layer of surface code ${\ell }_i^{xz}$ on each xz-plane that plays the role of the qubit q_i. Similarly, there is a layer of surface code on each xz-plane ${\ell }_j^{xz}$ that plays the role of the check $S_j^X$, and on each yz-plane ${\ell }_k^{yz}$ that plays the role of the check $S_k^Z$. The surface code layers have e-condensing gapped boundary conditions where they end on the xy faces of the cuboid and m-condensing gapped boundary conditions where they end on the yz faces of the cuboid. As described below, no surface code layers end on the xz faces of the cuboid.

The ${\ell }_j^{xy}$ and ${\ell }_k^{yz}$ surface code layers are joined to the ${\ell }_i^{xz}$ layers via topological defects that implement the X and Z checks of the concatenated code. One-dimensional topological defect line junctions that join a number of surface codes are specified by a set of independent and mutually bosonic anyons of size equal to the number of surface code half-planes that end on the defect. Each ${\ell }_j^{xy}$ surface code layer extends from layer ${\ell }_a^{xz}$ to ${\ell }_b^{xz}$ corresponding to the first and last qubits, q_a and q_b, in the support of check $S_j^X$. On the first and last qubit layers the topological line defect is specified by $⟨e_{xy}{e}_{xz}^{\left(1\right)}{e}_{xz}^{\left(2\right)},m_{xy}{m}_{xz}^{\left(1\right)},m_{xz}^{\left(1\right)}{m}_{xz}^{\left(2\right)}⟩$. Here $e_{xz}^{\left(1\right)}$ labels an e anyon on the relevant layer ${\ell }_i^{xz}$ and (1) indicates the anyon is on the side of the defect line with smaller z coordinate, while (2) labels the other side of the defect. We remark that e_xy does not have a superscript above since the relevant layer ${\ell }_j^{xy}$ ends on the defect line. The labeling of e and m anyons in the description of defects below proceeds similarly. On each of the remaining ${\ell }_i^{xz}$ surface code layers that correspond to qubits q_i in the support of the check $S_j^X$ the topological defect line is specified by $⟨e_{xy}^{\left(1\right)}{e}_{xy}^{\left(2\right)},e_{xy}^{\left(1\right)}{e}_{xz}^{\left(1\right)}{e}_{xz}^{\left(2\right)},m_{xy}^{\left(1\right)}{m}_{xz}^{\left(1\right)},m_{xz}^{\left(1\right)}{m}_{xz}^{\left(2\right)}⟩$. The ${\ell }_i^{xz}$ layers that the ${\ell }_j^{xy}$ layer crosses which do not correspond to qubits q_i in the support of check $S_j^X$ meet at simple line defects that describe the crossing of decoupled layers $⟨e_{xy}^{\left(1\right)}{e}_{xy}^{\left(2\right)},e_{xz}^{\left(1\right)}{e}_{xz}^{\left(2\right)},m_{xy}^{\left(1\right)}{m}_{xy}^{\left(2\right)},m_{xz}^{\left(1\right)}{m}_{xz}^{\left(2\right)}⟩$.

Analogous to the discussion in the paragraph above, each ${\ell }_k^{yz}$ surface code layer extends across the ${\ell }_i^{xz}$ layers that correspond to qubits q_i in the support of check $S_k^Z$. The line defects joining the first and last layers are specified by $⟨e_{yz}{e}_{xz}^{\left(1\right)},e_{xz}^{\left(1\right)}{e}_{xz}^{\left(2\right)},m_{yz}{m}_{xz}^{\left(1\right)}{m}_{xz}^{\left(2\right)}⟩$. The line defects joining the other layers that correspond to qubits in the support of the check are described by $⟨e_{yz}^{\left(1\right)}{e}_{yz}^{\left(2\right)}{e}_{xz}^{\left(1\right)},e_{xz}^{\left(1\right)}{e}_{xz}^{\left(2\right)},m_{yz}^{\left(1\right)}{m}_{yz}^{\left(2\right)},m_{yz}^{\left(1\right)}{m}_{xz}^{\left(1\right)}{m}_{xz}^{\left(2\right)}⟩$. The remaining ${\ell }_i^{xz}$ layers that the ${\ell }_k^{yz}$ layer meets correspond to qubits that are not in the support of the relevant check and these are specified by simple defects that describe decoupled layers crossing $⟨e_{xz}^{\left(1\right)}{e}_{xz}^{\left(2\right)},e_{yz}^{\left(1\right)}{e}_{yz}^{\left(2\right)},m_{xz}^{\left(1\right)}{m}_{xz}^{\left(2\right)},m_{yz}^{\left(1\right)}{m}_{yz}^{\left(2\right)}⟩$.

There are also defect lines along the $\widehat{y}$ direction where ${\ell }_j^{xy}$ and ${\ell }_k^{yz}$ layers meet. To describe these defects we first specify a pairing of the qubits q_i that are contained in the support of both an X-check $S_j^X$ and a Z-check $S_k^Z$. This pairing is simply given by grouping pairs of qubits in the support of both checks following the sequential ordering on q_i. The total number of qubits in the support of both checks must be even due to the commutativity of X and Z checks in the input CSS code. The pairing defines nontrivial line defect segments along the intersection of an ${\ell }_j^{xy}$ and ${\ell }_k^{yz}$ layer, which run between ${\ell }_i^{xz}$ layers that correspond to paired qubits. The defect along these lines is specified by $⟨e_{xy}^{\left(1\right)}{e}_{xy}^{\left(2\right)},e_{xy}^{\left(1\right)}{e}_{yz}^{\left(1\right)}{e}_{yz}^{\left(2\right)},m_{yz}^{\left(1\right)}{m}_{yz}^{\left(2\right)},m_{xy}^{\left(1\right)}{m}_{xy}^{\left(2\right)}{m}_{yz}^{\left(1\right)}⟩$. On the remainder of the intersection between ${\ell }_j^{xy}$ and ${\ell }_k^{yz}$ which does not contain any pairing lines, the layers simply pass through one another which is specified by the defect $⟨e_{xy}^{\left(1\right)}{e}_{xy}^{\left(2\right)},e_{yz}^{\left(1\right)}{e}_{yz}^{\left(2\right)},m_{xy}^{\left(1\right)}{m}_{xy}^{\left(2\right)},m_{yz}^{\left(1\right)}{m}_{yz}^{\left(2\right)}⟩$.

The line defects above meet at point defects, which are specified by the eigenvalues of string operators in the vicinity of the defect. The defects described in this section, and their lattice implementations, are defined in detail in Supplementary Notes III and V.

Code parameters

We now explain the code parameters that are achieved by the layer code construction. The construction maps the code parameters of an arbitrary input CSS code to an output layer code as follows

$$\begin{array}{c}\hfill \left[\left[n,k,d\right]\right]\mapsto \left[\left[\mathrm{\Theta }\left(n{n}_X{n}_Z\right),k,\mathrm{\Omega }\left(\right)\frac{1}{w}d\min \left(n_X,n_Z\right)\left)\right)\right]\right].\end{array}$$ 6

Here n_X is the number of X checks, n_Z the number of Z checks, and w the maximum weight of the checks in the input code. The output code is local in three-dimensional space and has checks of weight 6 or less. When a good CSS LDPC code is taken as input, the output code achieves parameters $\left[\left[N,\mathrm{\Theta }\left(N^{\frac{1}{3}}\right),\mathrm{\Theta }\left(N^{\frac{2}{3}}\right)\right]\right]=\left[\left[\mathrm{\Theta }\left(L^3\right),\mathrm{\Theta }\left(L\right),\mathrm{\Theta }\left(L^2\right)\right]\right]$, where L is the linear extent of the system. These code parameters are optimal in the sense that their scaling saturates the BPT bound for three spatial dimensions.

Below we discuss the scaling of the code parameters [[N, K, D]] of the layer code that is produced when our construction is applied to an input code with parameters [[n, k, d]].

Number of physical qubits: N = Θ(nn_Xn_Z)

The scaling of the number of physical qubits in the output code is lower bounded by the number of physical qubits in n layers of surface code with linear dimensions cn_X × cn_Z. Here c is a constant that sets the superlattice spacing between the surface code layers involved in the construction. On the other hand, N is upper bounded by the number of physical qubits in a stack of surface codes along the three lattice directions of a cn × cn_X × cn_Z cuboid.

This gives

$$\begin{array}{c}\hfill 2c^{2}n{n}_X{n}_Z\le N\le 6c^{3}n{n}_X{n}_Z\end{array}$$ 7

and hence N = Θ(nn_Xn_Z).

Number of logical qubits: K = k

The number of logical qubits in the output code is equal to the number of logical qubits in the input code. To demonstrate this, we consider a basis of representatives for the logical operator pairs in the input code

$$\left\{{\overline{X}}_i,{\overline{Z}}_i\left.∣\right)\left\{{\overline{X}}_i,{\overline{Z}}_i\right\}=0,\left[{\overline{X}}_i,{\overline{Z}}_j\right]=0,\text{for}i\ne j,i,j=1,\dots ,k\right\},$$ 8

where the ${\overline{X}}_i$ operators are products of physical X operators, and ${\overline{Z}}_i$ operators are products of physical Z operators. Here {A, B} = AB + BA denotes the anticommutator and [A, B] = AB − BA denotes the commutator. For each ${\overline{X}}_i,{\overline{Z}}_i,$ logical operator pair in the input code there is a corresponding logical operator pair ${\tilde{X}}_i,{\tilde{Z}}_i,$ in the output layer code.

We define a concatenated representative for the ${\overline{X}}_i$ logical in the layer code by replacing each physical X in the input code with an X string operator across the corresponding xz surface code layer. We remark that this concatenated representative operator would be a logical operator in a straightforward concatenation of surface code with the input code. However, this concatenated representative is not a logical operator in the layer code, as the string operators violate stabilizers on the yz Z-check layers that meet the relevant xz qubit surface code layers at nontrivial junctions. The number of such excitations created in each yz-layer must be even. This is because the incidence relation of the string operator in each xz surface code layer with the yz-layers via nontrivial junctions matches the incidence relation of the corresponding input physical qubit with the input Z checks. Hence the incidence of a concatenated representative operator on a yz-layer at nontrivial junctions matches the incidence of the relevant input logical on the associated input Z check, which must be even as they commute. We can then pair up the excitations within each yz-layer and remove all nontrivial syndromes via X string operators within yz-layers to form a logical operator ${\tilde{X}}_i$ that we call a quasiconcatenated representative. See Fig. 2 for a depiction of a quasiconcatenated logical operator in a repetition code example.

A quasiconcatenated representative for each ${\tilde{Z}}_i$ logical is obtained similarly with yz-layers replaced by xy-layers, and X string operators replaced by Z string operators. This construction preserves the (anti-)commutation relations of the logical operators, and guarantees that K ≥ k. To see this we note that the first step of the process, mapping single-qubit Pauli operators to string operators in layers of surface code, preserves commutation relations. The second step of the process, in which excitations are paired up in yz and xy-layers, does not affect the commutation relations. This follows from the fact that the X operators used to do the pairing within the yz-layers and the Z operators used to do the pairing within the xy-layers can be chosen to have disjoint support.

To complete the proof that K = k we must demonstrate both that there are no additional logical operators that have not been accounted for, and that none of the logical pairs in the output code we have counted are equivalent, up to multiplication with stabilizers. These statements follow from the detailed characterization of the logical operators in Supplementary Note IV.

Distance: $D=\mathrm{\Omega }\left(\frac{1}{w}d\min \left(n_X,n_Z\right)\right)$

We now discuss a lower bound on the weight of the quasiconcatenated representative logical operators. See Supplementary Note IV for a detailed proof that accounts for equivalence under all stabilizers in the layer code, going beyond the simplified cleaning process described below. Here, we focus on X-type logical operators but analogous statements hold for the Z-type logical operators of the output code.

We start by considering the quasiconcatenated representative logical operators ${\tilde{X}}_i$ in the output layer code. These operators are obtained from logical operators ${\overline{X}}_i$ in the input code by replacing each of their physical X operators by X string operators on the corresponding xz surface code layer and applying additional string operators in the yz-layers to pair up the excitations that the string operators in the xz-layers create. The weight of the quasiconcatenated representative is bounded from below by dcn_Z. However, the addition of the xy-layers introduce new equivalence relations for these logical operators that allow string operators on xz-layers that meet an xy-layer at nontrivial junctions to be moved onto the xy-layer. In the input code this corresponds to the associated logical operator ${\overline{X}}_i$ sharing support with part of an X stabilizer check. We assume that we have a minimum weight logical operator representative ${\overline{X}}_i$. The common support of this logical operator representative with any X stabilizer must be $\le \frac{w}{2}$, otherwise there would be an equivalent representative logical operator with lower weight thus contradicting the minimum weight assumption. The worst-case weight reduction via the new equivalence relations due to xy-layer mentioned above can only result in the weight being multiplied by $\frac{2}{w}$. This corresponds to all of the quasiconcatenated representative’s string operators in xz-layers being cleaned into xy-layers. Hence the weight lower bound retains the same scaling with n, given by $\mathrm{\Omega }\left(\frac{2}{w}dc{n}_Z\right)$, provided that the input code is LDPC.

In the case that the input code is not LDPC, we remark that the X distance of the output code still satisfies Ω(cn_Z). This is simply because the logical operators remain stringlike in the output layer code.

Energy barrier

In this subsection we demonstrate that the logical energy barrier of the output layer code Δ_out is lower bounded by a ratio of the logical energy barrier of the input code Δ_in to the product of maximum stabilizer weight w with the maximum number of checks that act on a common qubit $\widehat{w}$ in the input code

$$\frac{4{\mathrm{\Delta }}_{\mathrm{in}}}{w\widehat{w}}\le {\mathrm{\Delta }}_{\mathrm{out}}.$$ 9

We first remark that the energy barrier of the output code is upper bounded by the energy barrier of the input code plus 1. This follows by considering, without loss of generality, a sequence of Pauli X operators in the input code that attain its energy barrier and implement a nontrivial logical operator. Each individual Pauli X operator in this sequence can be mapped to a Pauli X string operator in the output code that can be sequentially implemented at the cost of at most one additional unit of energy on top of the energy penalty of the input X operator. As Pauli X string operators are sequentially implemented on the layer code, we can maintain a maximum of a single excitation within each yz-layer. This can be achieved by using string operators to move any excitation within a yz-layer to the appropriate location that will immediately annihilate any additional excitation that would be created in that layer via sequential application of an X string in some xz-layer. This process results in the implementation of a quasiconcatenated logical operator in the layer code with the claimed energy penalty, which is hence an upper bound on the energy barrier Δ_out. A similar argument applies for Pauli Z logical operators.

To derive a lower bound on the energy barrier we devise a method to convert any sequence of Pauli Z operators in the layer code into a different sequence that can then be used to define a sequence of Pauli Z operators on the input code. This conversion increases the energy penalty multiplicatively by at most a factor $w\widehat{w}$, where w is the max weight of a stabilizer check and $\widehat{w}$ is the maximum number of checks that act on a common qubit in the input code. Hence for input codes that are LDPC, the energy barrier of the output layer code retains the same scaling with n as the energy barrier of the input code.

We now describe the conversion process for a multi-qubit Pauli Z operator in a layer code. First, all e excitations within yz-layers are transformed into e excitations on xz-layers via string operators along the $\widehat{y}$ direction. There are two choices per yz-layer at this step, we take the one that produces the minimum number of excitations. This step increases the energy penalty multiplicatively by at most $\frac{w}{2}$. Next, we apply string operators to move all e excitations within xz-layers to condense at a rough boundary on an external xy face of the cuboid containing the layer code. Again there are two choices at this step for each e excitation, we take the choice that produces the minimum number of excitations. This step increases the energy penalty multiplicatively by at most $\frac{\widehat{w}}{2}$. At this point, all remaining e excitations are on xy-layers. We then apply string operators to bring all e excitations on each xy-layer to a common point. This step does not increase the energy penalty. The results shown in Supplementary Note IV establish that the Pauli operator produced by this procedure is equivalent to a quasiconcatenated operator that consists of up to one Z string operator per xz-layer, connected to one another and to the remaining e excitations by strings in xy-layers. Each such quasiconcatenated string operator defines a multi-qubit Pauli Z operator on the input code by mapping each Z string operator in an xz-layer to the Z operator on the associated input physical qubit.

Via the above mapping, any sequence of Pauli Z operators on the output code maps to a sequence of Pauli Z operators on the input code. For an LDPC code, a local change to the operator on the output code maps to a local change to the operator on the input code. Here local refers to combinatorial k-locality for a constant k. This is because the operator conversion process for a syndrome on any layer only involves other layers that meet the original layer at a nontrivial junction. Hence, a local sequence that implements a logical operator on the output code produces a local sequence that implements a logical operator on the input code. In doing so the energy penalty on the output code is increased multiplicatively by at most a factor $\frac{1}{4}w\widehat{w}$, and hence the energy barrier of the output code must satisfy the lower bound

$$\begin{array}{c}\hfill \frac{4{\mathrm{\Delta }}_{\mathrm{in}}\left(n\right)}{w\widehat{w}}\le {\mathrm{\Delta }}_{\mathrm{out}}\left(n\right).\end{array}$$ 10

Here, we are considering the less restrictive definition of the energy barrier that allows a sequence of local Pauli operators to be applied, see Supplementary Note IV. This result implies that the layer code construction preserves the scaling of the energy barrier with n for LDPC codes. We remark, however, that since our construction increases the number of physical qubits from n to Θ(nn_Xn_Z) the ration of the energy barrier divided by the number of physical qubits is generically decreased by the layer construction.

Author contributions

D.J.W. and N.B. both contributed extensively to the paper.

Peer review

Peer review information

Nature Communications thanks Jianxin Chen and the other, anonymous, reviewer(s) for their contribution to the peer review of this work. A peer review file is available.

Data availability

There was no data generated during this work.

Competing interests

The authors declare no competing interests.

Supplementary information

The online version contains supplementary material available at 10.1038/s41467-024-53881-3.