Optimal quantum subsystem codes in 2-dimensions

TL;DR

This paper presents a method to construct optimal 2D quantum subsystem codes from classical codes, achieving parameters that saturate known bounds and enabling efficient decoding, with potential for threshold behavior through gauge fixing.

Contribution

It introduces a construction of 2D quantum subsystem codes from classical codes that saturate Bravyi's bound and can be efficiently decoded using classical algorithms.

Findings

Constructed quantum codes with parameters $[[N,K,D]]$ satisfying $N o 2n_1n_2$, $K=k$, $D= ext{min}(d_1,d_2)$.

Utilized classical expander codes to build quantum codes with optimal parameters.

Provided a method to gauge fix subsystem codes to hypergraph product codes with asymptotic thresholds.

Abstract

Given any two classical codes with parameters $[n_1,k,d_1]$ and $[n_2,k,d_2]$, we show how to construct a quantum subsystem code in 2-dimensions with parameters $[[N,K,D]]$ satisfying $N\le 2n_1n_2$, $K=k$, and $D=\min(d_1,d_2)$. These quantum codes are in the class of generalized Bacon-Shor codes introduced by Bravyi. We note that constructions of good classical codes can be used to construct quantum codes that saturate Bravyi's bound $KD=O(N)$ on the code parameters of 2-dimensional subsystem codes. One of these good constructions uses classical expander codes. This construction has the additional advantage of a linear time quantum decoder based on the classical Sipser-Spielman flip decoder. Finally, while the subsystem codes we create do not have asymptotic thresholds, we show how they can be gauge-fixed to certain hypergraph product codes that do.

Figures

Equations

$$k=n-\text{rank}(H).$$

$$d=\min \{|\vec{w}|>0:\vec{w}\in \mathcal{C}\}.$$

$$n-k=n^T-k^T.$$

$$H_R$$

$$G_R$$

$$\mathcal{G}=⟨\mathcal{S}(\mathcal{G}),{\overline{X}}_1,{\overline{Z}}_1,\dots ,{\overline{X}}_{J(\mathcal{G})},{\overline{Z}}_{J(\mathcal{G})}⟩,$$

$$\text{For }S\in {\mathbb{F}}_2^{n_1\times n_2},$$

$$X(S_1)X(S_2)$$

$$\left[X(S_1),Z(S_2)\right]$$

$${\mathcal{C}}_1$$

$${\mathcal{C}}_2$$

$${\mathcal{G}}_X^{(\text{bbs})}$$

$${\mathcal{G}}_Z^{(\text{bbs})}$$

$${\mathcal{L}}_X^{(\text{bbs})}$$

$${\mathcal{L}}_Z^{(\text{bbs})}$$

$${\mathcal{S}}_X^{(\text{bbs})}$$

$$=\left\{X(S\cap A):S{H}_R^T=0,G_{1}S=0\right\},$$

$${\mathcal{S}}_Z^{(\text{bbs})}$$

$$=\left\{Z(S\cap A):H_{R}S=0,S{G}_2^T=0\right\}.$$

$$|{\mathcal{L}}_X^{(\text{bbs})}/{\mathcal{S}}_X^{(\text{bbs})}|=\frac{|{\mathcal{L}}_X^{(\text{bbs})}|}{|{\mathcal{S}}_X^{(\text{bbs})}|}=\frac{2^{n_1}}{|\ker (G_1)|}=2^k.$$

$${\hat{\mathcal{L}}}_X^{(\text{bbs})}$$

$${\hat{\mathcal{L}}}_Z^{(\text{bbs})}$$

$$\underset{g\in {\mathcal{G}}_X^{(\text{bbs})}}{\min }\left|gX\left(S\cap A\right)\right|=\left|G_R(S\cap A)\right|.$$

$$D_X$$

$$=\min \left\{|\vec{r}A|>0:\vec{r}\in {\mathbb{F}}_2^{n_1}\right\}$$

$$=\min \{|\vec{x}|>0:\vec{x}\in \text{row}(A)\}$$

$$=d_2,$$

$$D_Z$$

$$=\min \{|\vec{x}|>0:\vec{x}\in \text{col}(A)\}$$

$$=d_1.$$

$$N$$

$$K$$

$$D$$

$$D\min (n_1,n_2)\le \min (D_X{n}_1,D_Z{n}_2)\le |A|\le n_1{n}_2.$$

$$X^{(L_1)}(S_1)X^{(L_2)}(S_2)=X^{(L_1)}(T_1)X^{(L_2)}(T_2)$$

$${\mathcal{G}}_X^{(\text{abbs})}$$

$${\mathcal{G}}_Z^{(\text{abbs})}$$

$${\mathcal{G}}_{2d}=$$

$$\cup \{Z_{ij}^{(L_2)}{Z}_{i,j+1}^{(L_2)}:i\in [n_1],j\in [n_2-1]\}$$

Full text

I Introduction

One of the perhaps more surprising facts to come out of quantum information theory is the close relation between classical and quantum error-correcting codes. Exemplary of this relation is the Calderbank-Shor-Steane (CSS) construction Calderbank and Shor (1996); Steane (1996), which maps two classical codes (the first’s dual contained in the second) to a quantum code. Important concepts in classical coding have analogous quantum concepts. For instance, a good family of classical $[n,k,d]$ or quantum $\llbracket n,k,d\rrbracket$ codes is one that asymptotically achieves constant rate $k/n$ and constant relative distance $d/n$. Using the CSS construction, one can draw on what is known classically to prove the existence of asymptotically good families of quantum codes Calderbank and Shor (1996) and even construct them Ashikhmin et al. (2001); Chen (2001).

Because the classical codes input to the CSS construction must be related, it is sometimes difficult to use the CSS construction directly to make quantum codes with desirable properties. For example, the low-density parity check (LDPC) property, which can be defined for classical Gallager (1962) or quantum MacKay et al. (2004); Tillich and Zémor (2014) codes alike, demands that every parity or stabilizer check involves a constant number of bits or qubits and every bit or qubit is involved in a constant number of checks. It is pointed out in MacKay et al. (2004) that one needs to use bad (i.e. not good) classical LDPC codes to make quantum LDPC codes via the CSS construction, and that bad classical LDPC codes are uncommon, both because they are not worth studying if one is solely motivated by classical applications, but also because, asymptotically, most classical LDPC codes are actually good.

To easily create LDPC quantum codes, another method of converting classical codes to quantum ones has been developed. The hypergraph product Tillich and Zémor (2014) converts any two classical codes to a quantum code. Notably, if the constituent classical codes are LDPC, so is the quantum code. The popular surface code is a special case, the hypergraph product of two classical repetition codes.

Yet, due to anticipated hardware limitations, it is common to place even more practical constraints on quantum codes beyond the LDPC condition. A popular demand is that parity checks are geometrically local in 2-dimensions so that it is unnecessary to interact qubits that are physically far apart in the plane. Bounds are known on the parameters $\llbracket N,K,D\rrbracket$ of 2-dimensional quantum codes of stabilizer subspace Bravyi et al. (2010) and subsystem Bravyi (2011) varieties. The subspace bound $KD^{2}=O(N)$ is saturated constructively by the surface code Bravyi and Kitaev (1998); Kitaev (2003) and its relatives. The subsystem bound $KD=O(N)$ is known to be tight Bravyi (2011), but explicit constructions have heretofore been lacking.

Here, we establish another relation between classical and quantum codes. We show how to create an $\llbracket N,K,D\rrbracket$ quantum subsystem code that is local in 2-dimensions from any two classical codes with parameters $[n_{1},k,d_{1}]$ and $[n_{2},k,d_{2}]$ and prove that $N\leq 2n_{1}n_{2}$, $K=k$, and $D=\min(d_{1},d_{2})$. The quantum code belongs to the class of generalized Bacon-Shor codes introduced by Bravyi Bravyi (2011), a class we therefore refer to simply as Bravyi-Bacon-Shor codes. One can recover the traditional Bacon-Shor code Bacon (2006); Aliferis and Cross (2007) from our construction by starting with two classical repetition codes.

Bravyi-Bacon-Shor codes created this way have two important properties related to the constituent classical codes. First, if the classical codes are good, then the Bravyi-Bacon-Shor codes saturate the 2-dimensional subsystem code bound $KD=O(N)$. Second, decoders for the classical codes can be used to decode the quantum code. If the classical codes are LDPC and their decoders take linear time (in the size of the classical code), then the quantum decoding, including both data and measurement errors, takes linear time (in the size of the quantum code). Handling measurement errors in the quantum setting requires that the classical decoders handle errors in calculations of the parity checks. Though this is not a standard model in classical error-correction, the Sipser-Spielman flip decoder for expander codes Sipser and Spielman (1996) does apply to this situation Spielman (1996). Interestingly, decoding quantum expander codes Leverrier et al. (2015), a kind of hypergraph product code, also employs what is in some sense a quantum version of this classical flip decoder Fawzi et al. (2018a, b); Grospellier and Krishna (2018).

Finally, we show how to gauge-fix Bravyi-Bacon-Shor codes. This is the process of moving encoded data from a quantum subsystem code into a related subspace code. For instance, the Bacon-Shor code can be gauge-fixed to the surface code Li et al. (2018). Thus, as a generalization of Bacon-Shor codes, Bravyi-Bacon-Shor codes should gauge-fix to a generalization of the surface code. This is indeed the case. We show that a Bravyi-Bacon-Shor code can be gauge-fixed into certain hypergraph product codes – the hypergraph product of a classical repetition code and (either) one of the classical codes used to build the Bravyi-Bacon-Shor code. This reveals Bravyi-Bacon-Shor codes as a kind of subsystem hypergraph product code.

In Section II we review the codes we will be discussing and establish notation. In Section III, we provide our construction of Bravyi-Bacon-Shor codes from classical codes and show how to decode them. In Section IV, we gauge-fix Bravyi-Bacon-Shor codes to hypergraph product codes. Section V concludes.

II Code Background

In this section, we review the codes that play a major role in the paper. These are (a) classical codes, including transpose and LDPC codes, (b) quantum subsystem codes, (c,d) two versions of Bravyi-Bacon-Shor codes, and (e) hypergraph product codes.

II.1 Classical codes and their transposes

In this paper, we use “classical code” to mean a classical linear code. A linear code $\mathcal{C}$ is a subset of the set of length-$n$ bit strings $\mathcal{C}\subseteq\mathbb{F}_{2}^{n}$ and can be defined by a parity check matrix $H\in\mathbb{F}_{2}^{m\times n}$ by setting $\mathcal{C}=\ker(H)$. This means that $w\in\mathcal{C}$ if and only if $Hw=0$. Notice, however, that $H$ itself is not unique.

The number of encoded bits $k=\dim\mathcal{C}$ is related to the rank of $H$ by the rank-nullity theorem

[TABLE]

Gaussian elimination can be used to find a basis for the kernel of $H$. This basis can be arranged as the rows of a generating matrix $G\in\mathbb{F}_{2}^{k\times n}$ satisfying $\text{rank}(G)=k$ and $HG^{T}=0$. Of course, any $G^{\prime}=QG$ for full-rank matrix $Q\in\mathbb{F}_{2}^{k\times k}$ is an equally valid generating matrix.

The distance of the code is the minimum (Hamming) weight of a nonzero vector in $\mathcal{C}$. That is,

[TABLE]

Code parameters of $\mathcal{C}$ are collected in the tuple notation $[n,k,d]$.

Although not part of traditional classical coding theory, the “transposes” of a classical code will be important for defining hypergraph product codes in Section II.5. A code $\mathcal{C}^{T}$ is a transpose of $\mathcal{C}$ provided a parity check matrix $H$ exists so that $\mathcal{C}=\ker(H)$ and $\mathcal{C}^{T}=\ker(H^{T})$. Let us say that $H\in\mathbb{F}_{2}^{n^{T}\times n}$, where $T$ modifying a scalar (like $n$) is to be treated as a superscript (not the transpose). Thus, $\mathcal{C}^{T}$ is another linear code with parameters $[n^{T},k^{T},d^{T}]$. Codewords in $\mathcal{C}^{T}$ represent redundancy (linear dependencies) between parity checks, the rows of $H$. Indeed, by the rank-nullity theorem and the fact that the column rank and row rank of a matrix are equal,

[TABLE]

If $H$ were full rank (i.e. no check redundancy), $n^{T}=n-k$ and so $k^{T}=0$.

The $[n,1,n]$ repetition code $\mathcal{C}_{R}$ will be used at several points in this paper. Its parity check matrix (without redundancy) and its generating matrix can be written as

[TABLE]

When we use the repetition code, its length $n$ will be context-appropriate (e.g. so that matrix multiplications can work).

Finally, let us briefly define classical LDPC codes.

Definition 1** (classical LDPC Gallager (1962)).**

A classical code $\mathcal{C}$ is $(b,c)$-LDPC if there is a matrix $H\in\mathbb{F}_{2}^{(n-k)\times n}$ such that $\ker(H)=\mathcal{C}$, every column contains at most $b$ $1$s, and every row contains at most $c$ $1$s. We call $H$ an LDPC set of parity checks.

For example, the repetition code is $(2,2)$-LDPC with $H_{R}$ being an LDPC set of parity checks for the code.

II.2 Quantum subsystem codes

Before diving into the description of the quantum subsystem codes in this paper (the subsequent two sections), we review in this section some of the terminology surrounding subsystem codes in general.

Quantum subsystem codes Poulin (2005) are a generalization of quantum subspace codes Gottesman (1997). We restrict ourselves to the stabilizer formalism here in which both types of codes are specified by a subgroup of the Pauli group on $n$ qubits. For subspace codes, this is an abelian subgroup, the stabilizer group. For subsystem codes, this is an arbitrary subgroup, the gauge group $\mathcal{G}$. Subsystem codes are a generalization of subspace in the sense that if $\mathcal{G}$ is abelian, then the subsystem code is also a subspace code. In the general, possibly non-abelian case, we find it convenient to remove global phases from Pauli operators when defining groups of them.

Starting from the gauge group of a subsystem code, other important groups are derived.

The bare logical operators $\mathcal{L}(\mathcal{G})$: the set of all Paulis that commute with all elements of $\mathcal{G}$, also known in group theory as the centralizer of $\mathcal{G}$. 2. 2.

The stabilizers $\mathcal{S}(\mathcal{G})$: the intersection of $\mathcal{L}(\mathcal{G})$ with $\mathcal{G}$, also known as the center of $\mathcal{G}$. 3. 3.

The dressed logical operators $\hat{\mathcal{L}}(\mathcal{G})=\mathcal{G}\text{ }\mathcal{L}(\mathcal{G})$: the centralizer of $\mathcal{S}(\mathcal{G})$.

We point out that $\mathcal{G}=\mathcal{S}(\mathcal{G})$ if and only if the subsystem code is also a subspace code.

Code parameters are related to properties of the above groups. For instance, we denote by $K(\mathcal{G})$ the number of encoded qubits, i.e. $4^{K(\mathcal{G})}$ is the size of $\mathcal{L}(\mathcal{G})\setminus\mathcal{S}(\mathcal{G})$, the group of logical operators modulo stabilizers. By $D(\mathcal{G})$ we denote the code distance, the weight of the lowest weight element of $\hat{\mathcal{L}}(\mathcal{G})$.

Using a symplectic Gram-Schmidt procedure Wilde (2009), the gauge group can always be generated by

[TABLE]

where all generators commute except for pairs $\overline{X}_{i}$ and $\overline{Z}_{i}$. Thus, a subsystem code is seen to be a subspace code with stabilizer $\mathcal{S}(\mathcal{G})$, but including an additional $J(\mathcal{G})$ logical qubits that we do not protect. These additional logical qubits are referred to as gauge qubits. They are unprotected because error-correction proceeds by measuring a generating set of the gauge group, and thus by measuring the gauge qubits. An advantage afforded by this measurement scheme, compared to just measuring a generating set of $\mathcal{S}(\mathcal{G})$, is that the required measurements can be much lower weight. In some cases, such as the Bacon-Shor code and the subsystem codes considered in this paper, the difference in the weights of stabilizers and gauge operators can be factor of the code distance.

II.3 Bravyi-Bacon-Shor codes

Bravyi-Bacon-Shor (BBS) codes are defined entirely by a binary matrix $A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}$. Physical qubits of the code placed on sites $(i,j)$ of a $n_{1}\times n_{2}$ square lattice $L$ for which $A_{ij}=1$. If $|A|$ is the number of 1s in $A$, there are $N=|A|$ qubits in the code. Let us take a moment to establish notation for Pauli operators on this lattice.

A Pauli $X$ or $Z$ acting on the qubit at site $(i,j)$ in the lattice is written $X_{ij}$ or $Z_{ij}$. A Pauli operator acting on multiple qubits is specified by its support.

[TABLE]

Of course, $S$ should be such that $S_{ij}=1$ implies $A_{ij}=1$, because qubits only exist at those sites. We say $S\subseteq A$ if this is true. We also use the notation $S\cap A$ to indicate the pointwise product of binary matrices $S$ and $A$: $(S\cap A)_{ij}=S_{ij}A_{ij}$ for all $i,j$. It is always the case that $S\cap A\subseteq A$.

Conveniently, multiplication and commutation of Paulis are equivalent to addition and inner products of the support matrices,

[TABLE]

where $[P,Q]=PQP^{\dagger}Q^{\dagger}$ is the group commutator and $I$ the identity operator.

From $A$ we can also define two classical codes corresponding to its column-space and row-space:

[TABLE]

These accordingly have generating matrices $G_{1}$ and $G_{2}$, parity check matrices $H_{1}$ and $H_{2}$, and code parameters $[n_{1},k,d_{1}]$ and $[n_{2},k,d_{2}]$. Both $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$ encode the same number of bits $k=\text{rank}(A)=\text{rank}(G_{1})=\text{rank}(G_{2})$ because of the well-known equivalence of matrix row and column rank.

BBS codes are subsystem codes and, as such, are described by a gauge group of Pauli operators. This gauge group can be divided into $X$-type operators and $Z$-type ones, and so in this sense BBS codes are CSS subsystem codes. The gauge group is generated by $XX$ interactions between any two qubits sharing a column of lattice $L$ and $ZZ$ interactions between any two qubits sharing a row. We can write the entire gauge groups of $X$- and $Z$-type like

[TABLE]

recalling that $G_{R}=(1,1,\dots,1)$ is the generating matrix of the repetition code. Therefore, $G_{R}S=0$ implies that columns of $S$ have even weight and $SG_{R}^{T}=0$ implies its rows have even weight.

Bare logical operators of a subsystem code commute with all its gauge operators. In the case of BBS codes, to commute with all $Z$-type gauge operators, a bare logical $X$-type operator must be supported on entire rows of the lattice. Likewise, to commute with all $X$-type gauge operators, a bare logical $Z$-type operator must be supported on entire columns. Therefore,

[TABLE]

An example BBS code is shown in Fig. 1 with the gauge operators highlighted in part (a) and the logical operators in part (b).

When performing error-correction with a subsystem code, a complete generating set of gauge operators is measured. However, since not all gauge operators commute, the only reliable information gathered from this process is the eigenvalues of the stabilizers, the elements of the gauge group that do in fact commute with all gauge operators. In other words, the stabilizer is the intersection of the group of bare logical operators with the gauge group.

[TABLE]

Here $G_{1}S=0$ demands that each column of $S$ is a parity check of code $\mathcal{C}_{1}$ and thus intersects columns of $A$, which are codewords of $\mathcal{C}_{1}$, at an even number of places. Thus, $S\cap A$ has an even number of 1s in each column and this implies $X(S\cap A)$ is in $\mathcal{G}_{X}^{(\text{bbs})}$. Similar reasoning holds for the $Z$-type stabilizers.

The number of encoded qubits $K$ can be determined by counting the number of bare logical operators that are inequivalent under multiplication by stabilizers. That is, we would like the size of the quotient group $\mathcal{L}^{(\text{bbs})}_{X}/\mathcal{S}_{X}^{(\text{bbs})}$.

[TABLE]

Likewise, $|\mathcal{L}^{(\text{bbs})}_{Z}/\mathcal{S}_{Z}^{(\text{bbs})}|=2^{k}$. This implies $K=k=\text{rank}(A)$ encoded qubits.

Dressed logical operators are bare logical operators multiplied by any number of gauge operators.

[TABLE]

Equivalently, dressed logical operators are exactly those Pauli operators that commute with all stabilizers. The distance $D$ of the BBS code is the minimum nonzero weight of a dressed logical operator.

To calculate $D$, imagine first taking $X(S\cap A)\in\mathcal{L}_{X}^{(\text{bbs})}$ and reducing its weight by multiplying by gauge operators from $\mathcal{G}^{(\text{bbs})}_{X}$, which are two-qubit $X$ operators within columns. Clearly then, each column of $S\cap A$ can at best be reduced to contain either zero or one $1$ depending on the parity of the number of $1$s in that column. We calculate the parity of a column by taking its dot product with $G_{R}=(1,1,\dots,1)$. Thus,

[TABLE]

Note that $SH_{R}^{T}=0$ if and only if rows of $S$ are codewords of the classical repetition code, i.e. all 1s or all 0s. Accordingly, for some $\vec{r}\in\mathbb{F}_{2}^{n_{1}}$, $S\cap A=\text{diag}(\vec{r})A$, where $\text{diag}(\vec{r})$ is the square, diagonal matrix with $\vec{r}$ along the diagonal. Thus, $|G_{R}(S\cap A)|=|\vec{r}A|$, and

[TABLE]

by definition of the code distance of $\mathcal{C}_{2}=\text{row}(A)$. Likewise,

[TABLE]

The overall code distance of the BBS code is $D=\min(D_{Z},D_{X})=\min(d_{1},d_{2})$.

The discussion so far has reproduced Bravyi’s theorem

Theorem 2** (Bravyi Bravyi (2011)).**

The Bravyi-Bacon-Shor code constructed from $A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}$, denoted $\text{BBS}(A)$, is an $\llbracket N,K,D\rrbracket$ quantum subsystem code with gauge group generated by 2-qubit operators and

[TABLE]

Assuming without loss of generality that no row or column of $A$ is all [math]s (if there is such a row or column, then it can be removed without changing the code), it is worth noting the bounds

[TABLE]

The second inequality is based off the fact that each row (column) of $A$ needs to contain at least $D_{X}$ ($D_{Z}$) qubits.

II.4 Augmented Bravyi-Bacon-Shor codes

In this subsection, we discuss geometric locality of the BBS codes. In particular, we review the modification that makes them local in 2-dimensions.

Definition 3** (quantum LDPC codes).**

A subsystem code with gauge group $\mathcal{G}$ is $(\beta,\gamma)$-LDPC if, there is a subset $\mathcal{G}_{\text{ldpc}}\subseteq\mathcal{G}$ such that

• •

$\mathcal{G}_{\text{ldpc}}$ generates $\mathcal{G}$, i.e. $\mathcal{G}=\langle\mathcal{G}_{\text{ldpc}}\rangle$.

• •

each qubit is in the support of at most $\beta$ of the $g\in\mathcal{G}_{\text{ldpc}}$.

• •

the support of each $g\in\mathcal{G}_{\text{ldpc}}$ contains at most $\gamma$ qubits.

We refer to $\mathcal{G}_{\text{ldpc}}$ as an LDPC generating set.

Every BBS code is $(4,2)$-LDPC. An LDPC generating set $\mathcal{G}_{\text{ldpc}}$ contains just the two-qubit gauge operators between consecutive qubits in a row or column.

Definition 4** (quantum geometric locality).**

An infinite family of $(\beta,\gamma)$-LDPC subsystem codes is local in $M$-dimensions if there is a constant $\rho$ such that all codes in the family have an LDPC generating set $\mathcal{G}_{Md}$ and the qubits of the code can be arranged on vertices of an $M$-dimensional (hyper)cubic lattice in such a way that no two qubits in the support of the same $g\in\mathcal{G}_{Md}$ are more than (Manhattan) distance $\rho$ apart.

To attempt to show that a family of BBS codes is local in 2-dimensions, one might try $\mathcal{G}_{2d}=\mathcal{G}_{\text{ldpc}}$ from above. While this is of course an LDPC generating set, it is not necessarily true that elements of $\mathcal{G}_{2d}$ are supported in constant-sized regions of the 2-dimensional lattice. The difficulty is that $A$ may contain two consecutive $1$s in the same row or column that are separated by many [math]s (potentially a number of [math]s that grows with code size) and thus consecutive qubits are far apart.

To remedy this, Bravyi Bravyi (2011) introduces two more qubits at every site $(i,j)$ such that $A_{ij}=0$. One qubit participates in the two-qubit gauge operators of row $i$ and the other in the gauge operators of column $j$. Hence, we now say that there are three types of qubits making up the code – type 0 qubits reside at sites where $A_{ij}=1$, whereas type 1 and type 2 qubits reside at sites where $A_{ij}=0$. These qubit types can be used to define two lattices – $L_{1}$ consists of qubits of type 0 and type 1 and $L_{2}$ consists of qubits of type 0 and type 2. It is important to note that the lattices share the type 0 qubits, i.e. the lattices are identified at the sites where $A_{ij}=1$.

To distinguish Paulis acting on qubits in lattices $L_{1}$ or $L_{2}$, we use superscripts, e.q. $X^{(L_{1})}_{ij}$ or $X^{(L_{2})}_{ij}$ for single-qubit Paulis and $X^{(L_{1})}(S)$ or $X^{(L_{2})}(S)$ for Paulis acting on multiple qubits specified by support $S$. Of course, due to the identification of qubits between $L_{1}$ and $L_{2}$, a particular (say, $X$-type) Pauli $P$ does not have unique supports $S_{1},S_{2}$ such that $P=X^{(L_{1})}(S_{1})X^{(L_{2})}(S_{2})$. Indeed, letting $\mathbbm{1}$ be the matrix of all 1s,

[TABLE]

if and only if $S_{1}\cap(\mathbbm{1}-A)=T_{1}\cap(\mathbbm{1}-A)$, $S_{2}\cap(\mathbbm{1}-A)=T_{2}\cap(\mathbbm{1}-A)$, and $(S_{1}\cap A)+(S_{2}\cap A)=(T_{1}\cap A)+(T_{2}\cap A)$.

Using this notation, the augmented Bravyi-Bacon-Shor code (aBBS) has gauge groups

[TABLE]

Intuition for this gauge group arises by developing a generating set local in 2-dimensions. This generating set $\mathcal{G}_{2d}$ can be chosen to be the set of all two-qubit gauge operators on neighboring qubits in the lattices as well as all one-qubit gauge operators. That is, with $[t]=\{1,2,\dots,t\}$, we have

[TABLE]

This set, which has $4n_{1}n_{2}-(n_{1}+n_{2})-2|A|$ independent generators, is clearly local in 2-dimensions: it consists of two-qubit $X$ operators between qubits sharing a column in lattice 1, two-qubit $Z$ operators between qubits sharing a row in lattice 2, and single-qubit operators on type 1 and type 2 qubits. An example of $\mathcal{G}_{2d}$ for a $\llbracket 12,2,2\rrbracket$ aBBS code is shown in Fig. 2.

Bare logical operators and stabilizers of an aBBS code are derived similarly to those of a BBS code. Rather than go through those arguments again, we just record the results here.

[TABLE]

Code parameters $K$ and $D$ are also unchanged. Collecting this into a theorem, we have:

Theorem 5** (Bravyi Bravyi (2011)).**

The augmented Bravyi-Bacon-Shor code constructed from $A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}$, denoted $\text{aBBS}(A)$, is an $\llbracket N,K,D\rrbracket$ quantum subsystem code that is local in 2-dimensions, has a gauge group generated by 1- or 2-qubit operators, and

[TABLE]

II.5 Hypergraph Product Codes

Introduced in Tillich and Zémor (2014), the hypergraph product takes two classical parity check matrices $H_{1}\in\mathbb{F}_{2}^{n_{1}^{T}\times n_{1}}$ and $H_{2}\in\mathbb{F}_{2}^{n_{2}^{T}\times n_{2}}$ and produces a quantum code. The code ultimately is of CSS type (though the traditional CSS construction is not used to obtain it) and so its stabilizer group can be separated into stabilizers of Pauli $X$-type and those of Pauli $Z$-type.

Our description of the hypergraph product is a little unconventional but is in line with how we described BBS and aBBS codes, making it easier to relate the two later. It is essentially a description in terms of the “reshaped” matrices used at some points by Campbell Campbell (2019).

In our notation, qubits of the hypergraph product code are placed on the vertices of two square lattices (see Fig. 3). The first lattice $L$ is $n_{1}\times n_{2}$. The second lattice $l$ is $n_{1}^{T}\times n_{2}^{T}$. A Pauli $X$ or $Z$ acting on the qubit at site $(i,j)$ in lattice $L$ is denoted $X_{ij}^{(L)}$ or $Z_{ij}^{(L)}$ and similarly for Paulis acting in lattice $l$. A Pauli operator acting on multiple qubits is specified by its support, e.g. $X^{(L)}(S)$ or $Z^{(L)}(S)$, just as for the BBS and aBBS codes.

On the classical side, we define generating matrices $G_{1}$ and $G_{2}$ for the classical codes $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$ corresponding to $H_{1}$ and $H_{2}$. We define their code parameters as $[n_{1},k_{1},d_{1}]$ and $[n_{2},k_{2},d_{2}]$ and assume without loss of generality that they are nontrivial: $k_{1},k_{2}>0$. Similarly, let $F_{1}$ and $F_{2}$ be generating matrices for codes $\mathcal{C}_{1}^{T}$ and $\mathcal{C}_{2}^{T}$ with code parameters $[n_{1}^{T},k_{1}^{T},d_{1}^{T}]$ and $[n_{2}^{T},k_{2}^{T},d_{2}^{T}]$. Either transpose code may be trivial, in which case we define its distance to be infinite.

Using this notation, the hypergraph product of $H_{1}$ and $H_{2}$ is a quantum code $\text{HGP}(H_{1},H_{2})$ defined by the following sets of stabilizers, divided into $X$-type and $Z$-type,

[TABLE]

To show these stabilizers commute, let $M=X^{(L)}(S)X^{(l)}(T)\in\mathcal{S}^{(\text{hgp})}_{X}$ and $M^{\prime}=Z^{(L)}(S^{\prime})Z^{(l)}(T^{\prime})\in\mathcal{S}^{(\text{hgp})}_{Z}$. By Eq. (14), we need to show $\operatorname{tr}(S^{T}S^{\prime})+\operatorname{tr}(T^{T}T^{\prime})=0$. Notice that $G_{1}S=0$ demands that columns of $S$ are parity checks for $\mathcal{C}_{1}$. In other words, there exists $A$ such that $S=H_{1}^{T}A$. Likewise, because $TF_{2}^{T}=0$, rows of $T$ are parity checks for $\mathcal{C}_{2}^{T}$, or, equivalently, there exists $B$ such that $T=BH_{2}^{T}$. Finally, the same reasoning holds for $S^{\prime}$ and $T^{\prime}$, showing the existence of $A^{\prime}$ and $B^{\prime}$ such that $S^{\prime}=A^{\prime}H_{2}$ and $T^{\prime}=H_{1}B^{\prime}$. Since $SH_{2}^{T}=H_{1}^{T}T$ and $H_{1}S^{\prime}=T^{\prime}H_{2}$, we have $H_{2}A^{T}H_{1}=H_{2}B^{T}H_{1}$ and $H_{1}A^{\prime}H_{2}=H_{1}B^{\prime}H_{2}$. Putting it all together we have

[TABLE]

completing the proof.

In Appendix A, we connect this description of the hypergraph product code with the original definition, and derive other relevant properties. We note here that logical operators for $\text{HGP}(H_{1},H_{2})$ are

[TABLE]

and it has code parameters $\llbracket N,K,D\rrbracket$ Tillich and Zémor (2014):

[TABLE]

Lastly, if $H_{1}$ is a $(b_{1},c_{1})$-LDPC set of parity checks and $H_{2}$ is a $(b_{2},c_{2})$-LDPC set of parity checks, then $\text{HGP}(H_{1},H_{2})$ is $(\beta,\gamma)$-LDPC for Tillich and Zémor (2014)

[TABLE]

III Constructing and decoding optimal 2-dimensional subsystem codes

In this section, we show how to make BBS codes from two classical codes. We note that using good classical codes leads to optimal scaling of the quantum code parameters and show how classical decoders are used to decode the quantum codes.

III.1 Bravyi-Bacon-Shor codes from classical codes

In Section II.3 we noted that an $\llbracket N,K,D\rrbracket$ BBS code specified by matrix $A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}$ defines two classical codes $\mathcal{C}_{1}=\text{col}(A)$ and $\mathcal{C}_{2}=\text{row}(A)$, and that, if those classical codes have parameters $[n_{1},k,d_{1}]$ and $[n_{2},k,d_{2}]$, we have code parameter relations $K=k$ and $D=\min(d_{1},d_{2})$. The goal now is to explore the converse: given two classical codes $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$, how should we construct a BBS code with the same relations in code parameters?

Suppose that the classical codes have generating matrices $G_{1}\in\mathbb{F}_{2}^{k\times n_{1}}$ and $G_{2}\in\mathbb{F}_{2}^{k\times n_{2}}$. We then construct the code $\text{BBS}(A)$ with

[TABLE]

where $Q$ is any full-rank $k\times k$ matrix representing the non-uniqueness of the generating matrices. Adjusting $Q$ can change the number of physical qubits in the code.

Now notice that

[TABLE]

The second equality relies on $G_{2}$ being full-rank and the third on $Q$ being full-rank. Likewise, similar reasoning shows that $\text{row}(A)=\mathcal{C}_{2}$.

Therefore, we have the following theorem.

Theorem 6**.**

For all full-rank $Q\in\mathbb{F}_{2}^{k\times k}$ and every two classical codes $\mathcal{C}_{1}$, $\mathcal{C}_{2}$ with parameters $[n_{1},k,d_{1}]$, $[n_{2},k,d_{2}]$ and generating matrices $G_{1}\in\mathbb{F}_{2}^{k\times n_{1}}$, $G_{2}\in\mathbb{F}_{2}^{k\times n_{2}}$, let $A=G_{1}^{T}QG_{2}$. Then $\text{BBS}(A)$ is an $\llbracket N,K,D\rrbracket$ quantum subsystem code and $\text{aBBS}(A)$ an $\llbracket N_{2d},K,D\rrbracket$ subsystem code local in 2-dimensions with

[TABLE]

The lower bound on $N$ and upper bound on $N_{2d}$ are provided by Eq. (39).

Before discussing the theorem’s implications, let us briefly present some examples, starting with the Bacon-Shor code.

Example 1**.**

Let $\mathcal{C}_{1}=\mathcal{C}_{2}=\mathcal{C}_{R}$ be the $[n,1,n]$ repetition code (see Eq. (8)). Then $A=G_{R}^{T}G_{R}=\mathbbm{1}$ (the all $1$s matrix) represents a Bravyi-Bacon-Shor with a qubit at every lattice site, $X$-type ($Z$-type) gauge operators between pairs of qubits in the same column (row), and $X$-type ($Z$-type) stabilizers that span pairs of rows (columns). That is, we have reconstructed the Bacon-Shor code Bacon (2006).

Example 2**.**

The $[7,4,3]$ Hamming code is generated by

[TABLE]

Let $A=G^{T}QG$ for full-rank $4\times 4$ matrix $Q$. Taking $Q=I$ gives a $\llbracket 25,4,3\rrbracket$ Bravyi-Bacon-Shor code:

[TABLE]

Alternatively, taking $Q=\left(\begin{smallmatrix}0&0&1&0\\ 0&1&0&1\\ 1&0&0&0\\ 0&1&0&0\end{smallmatrix}\right)$ minimizes the number of qubits, giving a $\llbracket 21,4,3\rrbracket$ Bravyi-Bacon-Shor code.

In Bravyi (2011), Bravyi shows that for any family of $\llbracket N,K,D\rrbracket$ quantum subsystem codes local in 2-dimensions $KD=O(N)$. He then provides a nonconstructive argument that families of aBBS codes exist that saturate this bound. Theorem 6 elucidates this existence proof by connecting it to the classical case. If we have a family of good $[n,k,d]$ classical codes – i.e. there are constants $\alpha,\beta$ such that for all $n$, $k\geq\alpha n$ and $d\geq\beta n$ – then the aBBS code family created from Theorem 6 satisfies $KD=\alpha\beta n^{2}\geq\alpha\beta N_{2d}/2$. So the aBBS codes created this way saturate Bravyi’s bound.

Moreover, Theorem 6 provides the means to elevate the aforementioned nonconstructive proof to an explicit constructive proof. One only needs an explicit construction of good classical codes. Such constructions exist, e.g. expander codes. We review these classical codes in detail in Appendix B.1.

Finally, we should point out that although Theorem 6 produces BBS and aBBS codes for which $K,D=O(\sqrt{N})$, it can be used to trade off $K$ and $D$. Bravyi and Terhal Bravyi and Terhal (2009) have shown that $D=O(\sqrt{N})$ for subsystem codes in 2-dimensions. So, assume that we would like a code family with $K=\alpha N^{1-a}$ and $D=\beta N^{a}$ for some constants $a\leq 1/2$, $\alpha$, and $\beta$. To construct this code family, use Theorem 6 and a good family of classical codes to make a quantum code family with $K=\alpha N^{a}$, $D=\beta N^{a}$, and $O(N^{2a})$ physical qubits. Take $N^{1-2a}$ copies of this family to make the desired family with $K=\alpha N^{1-2a}N^{a}=\alpha N^{1-a}$, $D=\beta N^{a}$, and $N^{1-2a}O(N^{2a})=O(N)$ physical qubits.

If, for whatever reason, a family with parameters $KD=o(N)$ is desired (i.e. $KD$ scales strictly less than $N$), then one can take a family with $K^{\prime}D=\Theta(N)$ and ignore a fraction $1-K/K^{\prime}$ of the encoded qubits. See Fig. 4 for a summary of the last two paragraphs.

III.2 Decoding BBS codes

Correcting errors on a quantum subsystem code involves (1) measuring a generating set of gauge operators, (2) reconstructing the values of the stabilizers from the results, and (3) applying a Pauli correction. An advantage of the BBS or aBBS codes is that the generating set of gauge operators includes only 2-qubit operators (see Eq. 43) despite the stabilizers being high-weight. In this section, we identify another convenient feature – the correction in the third step can be calculated by decoders for the corresponding classical codes.

Let us begin by making some assumptions about the error model and codes. While not essential to the main conclusions, these assumptions simplify the discussion. Regarding the error model, we assume that each qubit suffers an $X$ error with probability $q$ and, independently, a $Z$ error with the same probability $q$. Two-qubit Pauli measurements (e.g. of the gauge operators) are assumed to fail with probability $q^{\prime}$. Regarding the codes, we assume that $A$ is an $n\times n$ symmetric matrix, so there is just one $[n,k,d]$ classical code $\mathcal{C}=\text{row}(A)=\text{col}(A)$ under consideration. We let $H$ and $G$ be the parity check and generating matrices of this code.

What is essential to our conclusions here is the existence of a decoding algorithm $\mathcal{D}$ for the classical code $\mathcal{C}$ of the following form. Decoder $\mathcal{D}$ takes as input faulty parity check information from a faulty codeword $\vec{i}=H(\vec{w}+\vec{e})+\vec{f}$, where $\vec{w}\in\mathcal{C}$, $\vec{e}$ represents data errors, and $\vec{f}$ represents errors in the “measurement” of the parity checks (though a more appropriate classical terminology might be the “calculation” of the checks). The decoder’s task is then to find a recovery $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}=\mathcal{D}(\vec{i})$ that is close to $\vec{e}$, and update the classical state from $\vec{w}+\vec{e}$ to $\vec{w}+\vec{e}+\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}$. This process is repeated some number of rounds, alternating the application of random noise $\vec{e}$ and $\vec{f}$ with decoding. Afterwards, we imagine “ideal” decoding with $\vec{f}=\vec{0}$ is performed, and if $\vec{w}$ is not the final state, then the error-correction has failed. Failure (after the given number of rounds) occurs with some probability $\bar{p}$, which is a function of the probability distribution of errors $\vec{e}$ and $\vec{f}$.

Generally, in classical error-correction, measurement of the parity checks is considered perfect, and so decoders with the required capability of dealing with measurement errors are seldom created or used. However, expander codes do have a suitable decoder, the flip decoder, which is discussed in Appendix B.2.

We discuss the decoding of (symmetric, $A=A^{T}$) BBS codes in detail, then in the next section briefly discuss the case of (symmetric) aBBS codes, which is similar. Our reasoning hinges on associating the stabilizers of the BBS code with parity checks of the classical code $\mathcal{C}$ and the dressed logical operators of the BBS code with the codewords of $\mathcal{C}$.

To realize these associations, we rewrite $\mathcal{S}_{X}^{(\text{bbs})}$ from Eq. (21). Let $X(S\cap A)\in\mathcal{S}_{X}^{(\text{bbs})}$. Since $SH_{R}^{T}=0$, rows of $S$ are codewords of $\mathcal{C}_{R}$, either all 1s or all 0s. Because $GS=0$, columns of $S$ are parity checks of $\mathcal{C}$. Therefore, $S\cap A=\text{diag}(\vec{r})A$ for some $\vec{r}\in\text{row}(H)$. We have

[TABLE]

Similarly, rewrite $\mathcal{S}_{Z}^{\text{(bbs)}}$ as

[TABLE]

Thus, the parity checks of the classical code indicate which sets of rows or columns constitute a stabilizer.

Dressed logical operators $\hat{\mathcal{L}}_{X}^{(\text{bbs})}$ are exactly those $X$-type Paulis that commute with all the $Z$-type stabilizers. But because $Z$-type stabilizers are supported on entire columns of $A$, they are only sensitive to whether an even or odd number of Pauli $X$ errors occurred within a column. Indeed, single qubit $X$ errors within a column are equivalent up to gauge operators. Say that a column is odd if it contains an odd number of $X$ errors. An $X$-type operator commutes with all the $Z$-type stabilizers if and only if it consists of odd columns corresponding to a codeword $\vec{w}\in\mathcal{C}$, i.e. column $i$ is odd if and only if $\vec{w}_{i}=1$. In other words, the even or oddness of a column corresponds to the 0 or 1 state of an effective classical bit of the code $\mathcal{C}$. Symmetry of $A$ dictates that the same correspondence holds for $Z$-type dressed logical operators $\hat{\mathcal{L}}_{Z}^{(\text{bbs})}$ and $Z$ errors in rows.

The upshot of the previous paragraph is that to decode a $\text{BBS}(A)$ code, we may collect $X$- or $Z$-type stabilizer information $\vec{\sigma}$, run the classical decoder $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}=\mathcal{D}(\vec{\sigma})$, and apply a $Z$- or $X$-type Pauli correction to a single qubit in each row or column indicated by $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}$. We call this the decoder induced by $\mathcal{D}$, or simply the induced decoder for $\text{BBS}(A)$. To evaluate how well the induced decoder works, we just need to map the quantum errors to the effective classical errors that the decoder $\mathcal{D}$ sees.

The probability that an odd number of $X$ errors occurs within column $i$ containing $c_{i}$ qubits is

[TABLE]

By symmetry, this situation is the same for $Z$ errors in the rows. So $p_{i}$ is the probability that bit $i$ has flipped in the classical code.

Similarly, stabilizers of the Bravyi-Bacon-Shor code are the product of several two-qubit gauge operators. For instance, there is an $Z$-type stabilizer $Z(A\hskip 2.0pt\text{diag}(\vec{h}_{j}))$ for row $\vec{h}_{j}$ of $H$, and it is made of $c_{j}^{\prime}=|A\hskip 2.0pt\text{diag}(\vec{h}_{j})|/2\leq n|\vec{h}_{j}|/2$ two-qubit gauge measurements. The probability this stabilizer measurement is incorrect depends only on whether an even or odd number of its constituent gauge measurements are incorrect:

[TABLE]

By symmetry, this situation is identical for the $X$-type stabilizers. Thus, $p_{j}^{\prime}$ is the probability that the parity check calculation for parity check $j$ is incorrect.

These relations between quantum and classical errors give us the following lemma.

Lemma 7**.**

Say that using decoder $\mathcal{D}$ on the classical error model in which data errors have probabilities $p_{i}$ and parity check errors have probabilities $p_{j}^{\prime}$ results in a logical error rate of $\bar{p}(p_{i},p_{j}^{\prime})$. The induced decoder with respect to $\mathcal{D}$ on an error model in which qubits fail with independent $X$ or $Z$ errors with probability $q$ and two-qubit Pauli measurements fail with probability $q^{\prime}$ has a logical error rate

[TABLE]

where $p_{i}$ and $p_{j}^{\prime}$ are given by Eqs. (78) and (79).

The factor of two in Eq. (80) results from the $X$ and $Z$ errors being decoded separately. Independent $X$, $Z$ noise is of course not critical to the lemma. For depolarizing noise for example, in which Pauli $X$, $Y$, or $Z$ errors occur with equal probability $q/3$, the logical error rate is at most $\bar{q}(2q/3,q^{\prime})$ since $2q/3$ is the probability of a $Z$ or $X$ error. On the other hand, the induced decoder does discount the correlations in $X$ and $Z$ noise, so is not expected to be optimal in this case.

Also crucial to note is that for small, constant $q$ and $q^{\prime}$, $p_{i}\approx c_{i}q$ and $p_{j}^{\prime}\approx c_{j}^{\prime}q^{\prime}$. Because $c_{i},c_{j}^{\prime}\geq d$, the effective classical error rates increase at least proportionally to the code distance. In the limit of large code size and distance, no classical code can be expected to correct such noise, and thus this shows the lack of asymptotic threshold for BBS codes. Nevertheless, the lemma indicates a close connection between the quantum and classical error rates. If a classical code has a “useful” (e.g. order $10^{-a}$ for some moderately large $a$) logical error rate for $p_{i}<p$ and $p_{j}^{\prime}<p^{\prime}$, then the quantum code has a useful (i.e. order $10^{-a}$) logical error rate for $q<p/(\max_{i}c_{i})$ and $q^{\prime}<p^{\prime}/(\max_{j}c_{j}^{\prime})$.

Lemma 7 indicates two ways to improve the decoding of BBS codes, even before tailoring to the noise. The first, more obvious way, is to find better decoders for the constituent classical codes. This is of course subject to the constraint that these classical decoders can tolerate measurement noise, which we noted previously is nonstandard but attainable for expander codes for example.

The second way to improve decoding is by reducing the values of $c_{i}$ (the number of qubits in row or column $i$) and $c_{j}^{\prime}$ (the number of gauge-operators making up stabilizer $j$). This correlates roughly with minimizing $|A|$, the number of qubits in the BBS code, which can be done without change in the code parameters by appropriate choice of $Q$ in Theorem 6.

Finally, let us discuss the time complexity of an induced decoder. This can be broken down into two parts: (1) the time it takes to acquire the stabilizer values that are input to $\mathcal{D}$ and (2) the time it takes to run $\mathcal{D}$ twice, once for $X$-stabilizers, once for $Z$. A particular stabilizer corresponding to a weight-$w$ parity check is the sum of $O(wn)$ two-qubit measurements and therefore takes $O(wn)$ time to compute. If $m$ stabilizer values are needed as input to the classical decoders, and the classical decoders run in time at most $t$, then induced decoding takes time $O(mwn+t)$. Using BBS codes constructed from classical expander codes as an example, the flip decoder $\mathcal{D}$ (see Appendix B.2) requires just $m=O(n)$ bits of input from weight $w=O(1)$ checks and runs in time $t=O(n)$. Thus, induced decoding takes time $O(n^{2}+n)=O(N)$, i.e. linear in the size of the quantum code.

III.3 Decoding aBBS codes

In this subsection, we briefly discuss the decoding of (symmetric, $A=A^{T}$) aBBS codes assuming we can only measure operators in $\mathcal{G}_{2d}$, Eq. (43), i.e. two-qubit operators on neighboring qubits and some single-qubit measurements. We still advocate using the induced decoder of the previous section, but it is now more difficult to collect the stabilizer values from this restricted set of gauge operator measurements.

Similar to how we derived Eqs. (76), (77), we can rewrite the stabilizers of the aBBS codes to correspond to classical parity checks (recall, $\mathbbm{1}$ is the matrix of all 1s):

[TABLE]

This leads to similar conclusions about errors on the effective bits of the classical code $\mathcal{C}$. With the recognition that $c_{i}=n$ for all $i$, Eq. (78) still represents the probability of error for an effective classical bit.

As one may expect, because we have restricted what gauge operators may be measured to those in $\mathcal{G}_{2d}$, aBBS decoding also differs from BBS decoding in how eigenvalues of the stabilizers are calculated. If $\vec{h}_{j}$ is a row of $H$ and $S=Z^{(L_{1})}(\mathbbm{1}\hskip 2.0pt\text{diag}(\vec{h}_{j}))$ is the corresponding stabilizer, then we should let $c_{j}^{\prime}$ be the minimal number of elements of $\mathcal{G}_{2d}$ whose product is $S$. Since $S$ may include rows that are $O(n)$ distance apart, $c_{j}^{\prime}$ may be as a large as $O(n^{2})$. With this redefinition of $c_{j}^{\prime}$ however, Eq. (79) again represents the probability of error for a parity check. Lemma 7 holds given these changes to $c_{i}$ and $c_{j}^{\prime}$.

Now we discuss the runtime. Because $c_{j}^{\prime}$ can be so large, we may be worried that it takes more time to decode, because ostensibly stabilizers corresponding to even just constant-weight parity checks may be the sum of as many as $O(n^{2})$ elements of $\mathcal{G}_{2d}$ (and note that $|\mathcal{G}_{2d}|=O(n^{2})$). However, a simple application of dynamic programming solves this. Suppose that we measure all two-body $Z$-gauge operators and get values $m_{ij}\in\{0,1\}$ corresponding to positions $(i,j)$ in the lattice. We can sweep across the lattice calculating the cumulative values across rows

[TABLE]

using just $O(n^{2})=O(N)$ time. $Z$-type stabilizers corresponding to constant-weight parity checks are once again the sum of $O(n)$ of the $M_{ij}$ as well as $O(n)$ single-qubit measurements. Symmetry dictates the same is true for $X$-type stabilizers. Therefore, for example, the induced decoder with respect to the flip decoder for aBBS codes constructed from classical expander codes can still be implemented in linear time.

IV Gauge-fixing

In this section, we show that an aBBS code can be gauge-fixed to the corresponding BBS code and to certain hypergraph product codes. We begin, however, by defining gauge-fixing in general.

IV.1 Definition

As we discussed in Section II.2, one way to think about subsystem codes is that in addition to the logical qubits encoded in the code, there are additional encoded qubits, the gauge qubits, which we do not care about protecting. In fact, the logical operators for these gauge qubits may be very low weight – they are the gauge operators that we measure to perform error-correction.

The existence of gauge qubits, however, leads us to imagine a family of related codes in which some or all of the gauge qubits are fixed to some stabilizer state ${\left|{\psi_{g}}\right\rangle}$. In these related codes, called gauge-fixings, we have removed some or all of the gauge degrees of freedom by removing operators from the gauge group that do not stabilize ${\left|{\psi_{g}}\right\rangle}$. Generally, this makes error-correction more difficult – a generating set for the new gauge group may necessarily contain higher weight operators – but by reducing the size of the group of dressed logical operators, the environment has fewer ways to introduce logical errors to the data. This may even result in asymptotic error-correction thresholds in the gauge-fixed codes where none existed in the original subsystem code. A well-known example is the gauge-fixing of the Bacon-Shor code to the surface code Li et al. (2018).

To discuss gauge-fixing in general, we use the following definition, using the notation from Section II.2.

Definition 8**.**

We say that $\mathcal{G}^{\prime}$ is a gauge-fixing of $\mathcal{G}$ if

$\mathcal{S}(\mathcal{G})\leq\mathcal{S}(\mathcal{G}^{\prime})\leq\mathcal{G}^{\prime}\leq\mathcal{G}$ 2. 2.

$K(\mathcal{G})=K(\mathcal{G}^{\prime})$

Generalizing the language slightly, we also say that a code $\mathcal{Q}^{\prime}$ is a gauge-fixing of a code $\mathcal{Q}$ if their gauge groups are related appropriately.

By the definition, a subsystem code and its gauge-fixing have the same total number of physical qubits and logical qubits. We can also say something about their code distances.

Lemma 9**.**

If $\mathcal{G}^{\prime}$ is a gauge-fixing of $\mathcal{G}$, then $\hat{\mathcal{L}}(\mathcal{G}^{\prime})\leq\hat{\mathcal{L}}(\mathcal{G})$ and $D(\mathcal{G}^{\prime})\geq D(\mathcal{G})$.

We prove this fact in Appendix C.

A concept more general than gauge-fixing is gauge-switching. If both $\mathcal{G}^{\prime}$ and $\mathcal{G}^{\prime\prime}$ are gauge-fixings of $\mathcal{G}$, then one can move encoded logical information from $\mathcal{G}^{\prime}$ to $\mathcal{G}^{\prime\prime}$ (or vice-versa) while keeping it protected with the stabilizers $\mathcal{S}(\mathcal{G}^{\prime})\cap\mathcal{S}(\mathcal{G}^{\prime\prime})\geq\mathcal{S}(\mathcal{G})$ and with code distance at least $D(\mathcal{G})$. Measuring the gauge group $\mathcal{G}^{\prime\prime}$, applying a correction based on the values of $\mathcal{S}(\mathcal{G})$ using a decoder for $\mathcal{G}$, and finally projecting onto the $+1$-eigenspaces of elements of $\mathcal{S}(\mathcal{G}^{\prime\prime})-\mathcal{S}(\mathcal{G})$ using the appropriate elements of $\mathcal{G}$ achieves this information transfer.

IV.2 Gauge-fixing an aBBS code to a BBS code

To warm up to Definition 8, we show that a BBS code specified by binary matrix $A$ is a gauge-fixing of the aBBS code specified by the same matrix. Of course, these codes do not have the same number of physical qubits, so to make the previous sentence precise we include ancilla qubits to the BBS code. This will be a common occurrence in our gauge-fixing theorems, and so we take a moment to discuss it.

Given a quantum code $\mathcal{Q}$, we will consider appending three types of ancillas: (1) qubits in the ${\left|{+}\right\rangle}$ state, (2) qubits in the ${\left|{0}\right\rangle}$ state, and (3) bare gauge qubits denoted ${\left|{\perp}\right\rangle}$. The new code that includes ancillas is written $\mathcal{Q}{\left|{+^{m_{+}}}\right\rangle}{\left|{0^{m_{0}}}\right\rangle}{\left|{\perp^{m_{g}}}\right\rangle}$ with the number of each type of ancilla indicated. Appending ancillas in this way extends the code’s gauge group. Ancillas ${\left|{+}\right\rangle}$ indicate the inclusion of Paulis $X_{i}$ into the gauge group for each ancilla index $i$. Likewise, ${\left|{0}\right\rangle}$ ancillas indicate inclusion of $Z_{i}$. Bare gauge qubits ${\left|{\perp}\right\rangle}$ indicate inclusion of both $X_{i}$ and $Z_{i}$.

Now we can formally state the relation between $\text{BBS}(A)$ and $\text{aBBS}(A)$.

Theorem 10**.**

For all binary matrices ${A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}}$, $\mathcal{Q}^{\prime}=\text{BBS}(A){\left|{+^{n_{1}n_{2}-|A|}}\right\rangle}{\left|{0^{n_{1}n_{2}-|A|}}\right\rangle}$ is a gauge-fixing of $\mathcal{Q}=\text{aBBS}(A)$.

Proof.

We place both codes on the lattices $L_{1}$ and $L_{2}$ defined in Section II.4 for the aBBS codes (recall, two $n_{1}\times n_{2}$ lattices that share qubits wherever $A_{ij}=1$). The gauge group of $\mathcal{Q}$ is defined in Eqs. (41), (42). For $\mathcal{Q}^{\prime}$, however, we should rewrite the gauge group to fit on these two lattices and to include the ancillas. As one may suspect from their quantity, the ${\left|{+}\right\rangle}$ ancillas are the type 2 qubits (recall, those in $L_{2}$ but not in $L_{1}$) and ${\left|{0}\right\rangle}$ ancillas are the type 1 qubits (those in $L_{1}$ but not $L_{2}$).

[TABLE]

Stabilizers of $\mathcal{Q}^{\prime}$ include not just the stabilizers of $\text{BBS}(A)$, but also single-qubit Pauli $X$s on type 2 qubits and single-qubit Pauli $Z$s on the type 1 qubits. So we have

[TABLE]

Now it is clear that

[TABLE]

This takes care of part (1) of Definition 8.

Adding ancillas does not change the number of logical qubits in $\mathcal{Q}^{\prime}$, and so both $\mathcal{Q}^{\prime}$ and $\mathcal{Q}$ have $\text{rank}(A)$ logical qubits, showing part (2) of Definition 8 holds. ∎

IV.3 Gauge-fixing an aBBS code to hypergraph product codes

In this section, we show that certain hypergraph product codes are gauge-fixings of an aBBS code. Informally, our main result is that for all $A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}$ both $\text{HGP}(H_{R},H_{2})$ and $\text{HGP}(H_{1},H_{R})$ are gauge-fixings of $\text{aBBS}(A)$, where we only require that the rows of $H_{1}\in\mathbb{F}_{2}^{n_{1}^{T}\times n_{1}}$ and $H_{2}\in\mathbb{F}_{2}^{n_{2}^{T}\times n_{2}}$ span $\ker(A^{T})$ and $\ker(A)$, respectively.

Just like the case of a BBS code in the last section, to formalize this gauge-fixing we need to define all three of these codes on the same set of physical qubits. Four lattices of qubits are involved, which we label $L_{1}$, $L_{2}$, $l_{1}$, and $l_{2}$. The code $\text{aBBS}(A)$ is supported on the $n_{1}\times n_{2}$ lattices $L_{1}$ and $L_{2}$. Recall that qubits in $L_{1}$ and $L_{2}$ are identified at the positions where $A_{ij}=1$, so there are $2n_{1}n_{2}-|A|$ total qubits in $L_{1}\cup L_{2}$. The code $\text{HGP}(H_{R},H_{2})$ is supported on lattices $L_{1}$ and $l_{1}$, thus making $l_{1}$ a $(n_{1}-1)\times n_{2}^{T}$ lattice. Similarly, the code $\text{HGP}(H_{1},H_{R})$ is supported on lattices $L_{2}$ and $l_{2}$, and so $l_{2}$ is a $n_{1}^{T}\times(n_{2}-1)$ lattice. A schematic of this qubit arrangement is shown in Fig. 5.

Theorem 11**.**

Let $A\in\mathbb{F}_{2}^{n_{1}\times n_{2}}$ and $H_{1}\in\mathbb{F}_{2}^{n_{1}^{T}\times n_{1}}$, $H_{2}\in\mathbb{F}_{2}^{n_{2}^{T}\times n_{2}}$ be such that $\text{row}(H_{1})=\ker(A^{T})$, $\text{row}(H_{2})=\ker(A)$. Then the codes

[TABLE]

are gauge-fixings of

[TABLE]

Proof.

We just prove that $\mathcal{Q}^{\prime}$ is a gauge-fixing of $\mathcal{Q}$ because proving the same for $\mathcal{Q}^{\prime\prime}$ is analogous. To prove this half of the theorem, we do not need lattice $l_{2}$ and so omit it when we write down Pauli operators. Indeed, without $l_{2}$, code $\mathcal{Q}^{\prime}$ is a subspace code – its gauge group is its stabilizer group.

Parity check matrices $H_{1}$ and $H_{2}$ define classical codes $\mathcal{C}_{1}=\text{col}(A)$ and $\mathcal{C}_{2}=\text{row}(A)$, each encoding $k=\text{rank}(A)$ bits. These codes have some generating matrices $G_{1}$ and $G_{2}$ that we will use. Code $\mathcal{C}_{2}^{T}$ has a generating matrix $F_{2}$. By the discussions in Section II, we have that both $\mathcal{Q}^{\prime}$ and $\mathcal{Q}$ encode $k$ qubits, thus verifying part (2) of the gauge-fixing definition, Definition 8.

Now, let us write down the stabilizers of $\mathcal{Q}^{\prime}$ and the gauge group and stabilizers of $\mathcal{Q}$. These follow from the appropriate equations in Section II, but with additions due to the ancillas: ${\left|{+}\right\rangle}$ ancillas in $L_{2}-L_{1}$ for $\mathcal{Q}^{\prime}$ and ${\left|{\perp}\right\rangle}$ ancillas in $l_{1}$ for $\mathcal{Q}$.

[TABLE]

To show part (1) of Definition 8, we have four inclusions to prove: (a) $\mathcal{S}_{X}^{(\mathcal{Q}^{\prime})}\subseteq\mathcal{G}_{X}^{(\mathcal{Q})}$, (b) $\mathcal{S}_{Z}^{(\mathcal{Q})}\subseteq\mathcal{S}_{Z}^{(\mathcal{Q}^{\prime})}$, (c) $\mathcal{S}_{Z}^{(\mathcal{Q}^{\prime})}\subseteq\mathcal{G}_{Z}^{(\mathcal{Q})}$, (d) $\mathcal{S}_{X}^{(\mathcal{Q})}\subseteq\mathcal{S}^{(\mathcal{Q}^{\prime})}_{X}$.

Both inclusions (a) and (b) are obvious, so we focus on (c) and (d). For (c), let $M=Z^{(L_{1})}(S)Z^{(l_{1})}(T)\in\mathcal{S}_{Z}^{(\mathcal{Q}^{\prime})}$. Set $S_{1}=S\cap(\mathbbm{1}-A)$ and $S_{2}=S\cap A$, so that $M=Z^{(L_{1})}(S_{1})Z^{(L_{2})}(S_{2})Z^{(l_{1})}(T)$. Now $SG_{2}^{T}=0$ implies that rows of $S$ are parity checks of code $\mathcal{C}_{2}$. Since rows of $A$ are codewords of $\mathcal{C}_{2}$, each row of $S_{2}=S\cap A$ contains an even number of 1s. Thus, $S_{2}=S_{2}G_{R}^{T}=0$, and so $M\in\mathcal{G}_{Z}^{(\mathcal{Q})}$.

For (d), let $M=X^{(L_{2})}(S)\in\mathcal{S}_{X}^{(\mathcal{Q})}$. Set $S_{1}=S\cap A$ and $S_{2}=S\cap(\mathbbm{1}-A)$. Since $G_{1}S=0$, columns of $S$ are parity checks of $\mathcal{C}_{1}$. Columns of $A$ are codewords of $\mathcal{C}_{1}$, and so each column of $S_{1}$ contains an even number of 1s, or $G_{R}S_{1}=0$. Similarly, $SH_{R}^{T}=0$ implies that rows of $S$ are codewords of $\mathcal{C}_{R}$, i.e. all 1s or all 0s. Therefore, $\text{row}(S_{1})\subseteq\text{row}(A)=\mathcal{C}_{2}$ and $S_{1}H_{2}^{T}=0$. This shows $M=X^{(L_{1})}(S_{1})X^{(L_{2})}(S_{2})X^{(l_{1})}(0)\in\mathcal{S}_{X}^{(\mathcal{Q}^{\prime})}$. ∎

A special case of Theorem 11 is the gauge-fixing of the Bacon-Shor code $\text{BBS}(\mathbbm{1})=\text{aBBS}(\mathbbm{1})$ (see Example 1) to the surface code $\text{HGP}(H_{R},H_{R})$ (see Example 3 in the Appendix).

Let us conclude this section by briefly discussing the code $\text{HGP}(H_{1},H_{R})$ that we just showed is a gauge-fixing of $\text{aBBS}(A)$. In particular, we would like to argue that it has an asymptotic threshold when $H_{1}$ is chosen appropriately. Kovalev and Pryadko Kovalev and Pryadko (2013) have shown that any $\llbracket N,K,D\rrbracket$ quantum code family that is $(\beta,\gamma)$-LDPC for constants $\beta$ and $\gamma$ and has distance scaling at least logarithmically in code size, i.e. $D=\Omega(\log N)$, possesses an asymptotic threshold. Say that $H_{1}$ is a full-rank, $(b,c)$-LDPC set of parity checks for code $\mathcal{C}_{1}$ with parameters $[n,k,d]$ and $H_{R}$ represents the length $n$ repetition code. Then, $\text{HGP}(H_{1},H_{R})$ is $(\gamma,\gamma)$-LDPC for $\gamma=\max(b,c)+2$ and has parameters $\llbracket N,k,d\rrbracket$ with $N\leq 2n^{2}$. Clearly then, if $\mathcal{C}_{1}$ is an LDPC code family with $d$ scaling at least logarithmically in $n$, i.e. $d=\Omega(\log n)$, then by Kovalev and Pryadko (2013) the quantum code family $\text{HGP}(H_{1},H_{R})$ has an asymptotic threshold.

V Discussion

We have presented another connection between classical and quantum error-correction and discussed one of its consequences, the construction of Bravyi-Bacon-Shor subsystem codes that are local in 2-dimensions and have optimal parameters. We also showed a somewhat surprising connection between Bravyi-Bacon-Shor codes and the hypergraph product codes via the process of gauge-fixing.

We briefly point out two somewhat obvious but interesting properties of any gauge-fixing $\mathcal{Q}^{\prime}$ of Bravyi-Bacon-Shor codes, including e.g. $\text{HGP}(H_{1},H_{R})$. First, if the Bravyi-Bacon-Shor codes are optimal, then $\mathcal{Q}^{\prime}$ is not local in 2-dimensions. This is necessarily the case because if an $\llbracket N,K,D\rrbracket$ subsystem code local in 2-dimensions can be gauge-fixed to a $\llbracket N,K,D^{\prime}\rrbracket$ subspace code ($D^{\prime}\geq D$ by Lemma 9) local in 2-dimensions, then $KD^{\prime 2}=O(N)$ by Bravyi et al. (2010) implying that $KD<KD^{2}\leq O(N)$, i.e. the subsystem code is suboptimal. This is also why the 2-dimensional “topological” subsystem codes (see e.g. Bombín (2010); Suchara et al. (2011); Andrist et al. (2012); Sarvepalli and Brown (2012); Bravyi et al. (2013)), which are defined by having stabilizer groups that are local in 2-dimensions, cannot actually compete, despite being subsystem codes, for the $KD=O(N)$ bound.

Second, $\mathcal{Q}^{\prime}$ does not have constant rate. Indeed, simply rearranging the subsystem bound we get $K/N=O(1/D)$, which vanishes provided the code family has growing distance. Thus, it is impossible to gauge-fix Bravyi-Bacon-Shor codes to hypergraph product codes with constant rate, which is interesting because obtaining constant rate quantum codes is one of the most notable properties of the general-case hypergraph product construction Tillich and Zémor (2014). Instead, we necessarily ended up gauge-fixing to a special case $\text{HGP}(H_{1},H_{R})$ without constant rate.

On the other hand, one of the interesting consequences of our results is the ability to gauge-switch between several hypergraph product codes. For example, one can switch between $\text{HGP}(H_{R},H_{2})$ and $\text{HGP}(H_{1},H_{R})$ for any $H_{1}$ and $H_{2}$ or between $\text{HGP}(H_{1},H_{R})$ and $\text{HGP}(H_{1}^{\prime},H_{R})$ where $H_{1}$ and $H_{1}^{\prime}$ are different parity check matrices for the same classical code. In the process, encoded data is protected by the underlying augmented Bravyi-Bacon-Shor code (see Theorem 11), which has the same code distance as the hypergraph product codes in question although it lacks an asymptotic threshold. Nonetheless, generalizing this gauge-switching idea to more hypergraph product codes would be an interesting extension of our work here.

Acknowledgements

The author gratefully acknowledges helpful discussions with Sergey Bravyi, Ken Brown, Chris Chamberland, and Andrew Cross. Partial support for this project was generously provided by the IBM Research Frontiers Institute.

Appendix A Hypergraph product codes

In this appendix, we review the original presentation of hypergraph product codes Tillich and Zémor (2014) and verify that our description in Section II.5 is equivalent. We also review the derivation of the hypergraph product code parameters. Mainly, our arguments are similar to those in Tillich and Zémor (2014) and Campbell (2019).

Recall that the input to the construction is two parity check matrices $H_{1}\in\mathbb{F}_{2}^{n_{1}^{T}\times n_{1}}$ and $H_{2}\in\mathbb{F}_{2}^{n_{2}^{T}\times n_{2}}$. These have corresponding full-rank generating matrices $G_{1}\in\mathbb{F}_{2}^{k_{1}\times n_{1}}$ and $G_{2}\in\mathbb{F}_{2}^{k_{2}\times n_{2}}$ for the classical codes $\mathcal{C}_{1}$ and $\mathcal{C}_{2}$. Without loss of generality, we assume $k_{1},k_{2}>0$. Additionally, there are full-rank generating matrices $F_{1}\in\mathbb{F}_{2}^{k_{1}^{T}\times n_{1}^{T}}$ and $F_{2}\in\mathbb{F}_{2}^{k_{2}^{T}\times n_{2}^{T}}$ for the transpose classical codes $\mathcal{C}^{T}_{1}$ and $\mathcal{C}^{T}_{2}$.

In the original description, the supports of Pauli operators are specified by vectors from $\mathbb{F}_{2}^{N}$ with $N=n_{1}n_{2}+n_{1}^{T}n_{2}^{T}$. Generating sets of $X$- and $Z$-type stabilizers are presented as rows of matrices:

[TABLE]

where $I_{n}$ is the $n\times n$ identity matrix. That is, if $X^{\vec{v}}=\prod_{i=1}^{N}X_{i}^{\vec{v}_{i}}$ and we wanted to write out the entire sets of Pauli stabilizers, we would have

[TABLE]

It is easy to see that these stabilizers commute, because $S_{X}S_{Z}^{T}=0$. Moreover, from the generating sets in Eqs. (100), (102), we note that using classical LDPC parity checks $H_{1}$ and $H_{2}$ lead to a quantum LDPC code with the appropriate parameters from Eqs. (65), (66).

We can calculate the number of encoded qubits by finding the number of independent stabilizer generators $\text{rank}(S_{X})+\text{rank}(S_{Z})$ and subtracting that from $N$. Basic linear algebra says

[TABLE]

Since

[TABLE]

has kernel

[TABLE]

we see that $\dim(\ker(S_{X}^{T}))=\dim(\mathcal{C}_{1})\dim(\mathcal{C}_{2}^{T})=k_{1}k_{2}^{T}$. A similar argument holds for $S_{Z}$. Thus, we have

[TABLE]

Accordingly, the hypergraph product code encodes

[TABLE]

qubits. For the third equality, we used Eq. (3). This verifies Eq. (61).

Let us create a generating set of logical operators for these qubits. We notice that

[TABLE]

do in fact provide sets of logical operators because $S_{Z}L_{X}^{T}=0$ and $S_{X}L_{Z}^{T}=0$ demonstrate the appropriate commutation.

To show that these are indeed complete sets of logical operators, we can calculate the rank of $C=L_{X}L_{Z}^{T}$, which encodes how the $X$- and $Z$-type logical operators commute. There should be $K$ independent, anti-commuting pairs of logical operators, so the rank of $C$ should be $K$. Since

[TABLE]

we do have

[TABLE]

We also point out that the last rows of $L_{X}$ and $L_{Z}$ (those involving $F_{1}$ and $F_{2}$) only contain nontrivial logical operators if both $F_{1}$ and $F_{2}$ are nontrivial matrices (i.e. both $k_{1}^{T}$ and $k_{2}^{T}$ are greater than zero).

Now consider “reshaping” Campbell (2019) the vectors that represent Paulis into matrices. Let $\hat{e}_{i}$ be the unit vector $(\hat{e}_{i})_{j}=\delta_{ij}$. A vector $\vec{s}\in\mathbb{F}_{2}^{n_{1}n_{2}}$ can be decomposed as

[TABLE]

where $S$ is the matrix corresponding to $\vec{s}$ and the support of Pauli $X^{\vec{s}}$ once we have placed it on the $n_{1}\times n_{2}$ lattice $L$. We previously wrote this Pauli as $X^{(L)}(S)$. Likewise, vectors $\vec{t}\in\mathbb{F}_{2}^{n_{1}^{T}n_{2}^{T}}$ are reshaped to represent Paulis on the $n_{1}^{T}\times n_{2}^{T}$ lattice $l$.

Linear transformations of $\vec{s}$ correspond to matrix multiplications on $S$. By Eq. (125),

[TABLE]

Likewise with transformations on $\vec{t}$.

At this point we can justify our presentation of the stabilizers and logical operators, Eqs. (54, 55) and (58, 59) in the main text. We can characterize elements of $\text{row}(S_{X})$ by the fact that they commute with all rows of $L_{Z}$.

[TABLE]

Reshaping the linear equations on the right using Eq. (126) gives the equations

[TABLE]

which are exactly the conditions on $S$ and $T$ in $\mathcal{S}^{(\text{hgp})}_{X}$, Eq. (54).

Similarly, elements of $\text{row}(S_{Z})$ are characterized by commutation with rows of $L_{X}$, elements of $\text{row}(L_{X})$ by commutation with rows of $S_{Z}$, and elements of $\text{row}(L_{Z})$ by commutation with rows of $S_{X}$. After reshaping the appropriate linear equations, one can confirm Eqs. (55, 58, 59).

Finally, we prove that the hypergraph product code has the claimed distance from Eq. (64). We begin by bounding the weight of nontrivial $X$-type logical operators, those elements of $\mathcal{L}_{X}^{(\text{hgp})}-\mathcal{S}_{X}^{(\text{hgp})}$. If $M=X^{(L)}(S)X^{(l)}(T)$, then $SH_{2}^{T}=H_{1}^{T}T$ and there is an $M^{\prime}\in\mathcal{L}_{Z}^{(\text{hgp})}-\mathcal{S}_{Z}^{(\text{hgp})}$ that anticommutes with $M$. In fact, given the basis in $L_{Z}$, Eq. (121), we know something about the form of $M^{\prime}$ – it corresponds either to a row of $G_{1}\otimes I_{n_{2}}$ (case (1)) or, if $k_{1}^{T},k_{2}^{T}>0$, to a row of $I_{n_{1}^{T}}\otimes F_{2}$ (case (2)).

In case (1), we can take $M^{\prime}=X^{(L)}(S^{\prime})$ where $S^{\prime}$ is an outer product $S^{\prime}=\vec{c}\hskip 2.0pt\hat{e}_{j}^{T}$ for some $\vec{c}\in\mathcal{C}_{1}$ and some $j$. As $M$ and $M^{\prime}$ anticommute,

[TABLE]

and clearly $S^{T}\vec{c}\neq\vec{0}$. Now, $H_{2}S^{T}\vec{c}=T^{T}H_{1}\vec{c}=0$ and thus $S^{T}\vec{c}$ is a nonzero vector in $\ker(H_{2})=\mathcal{C}_{2}$. Therefore, $|M|\geq|S|=|S^{T}|\geq|S^{T}\vec{c}|\geq d_{2}$.

In case (2), which is relevant only if $k_{1}^{T},k_{2}^{T}>0$, the argument is analogous. Take $M^{\prime}=X^{(l)}(T^{\prime})$ where $T^{\prime}$ is the outer product $T^{\prime}=\hat{e}_{i}\hskip 1.0pt\vec{b}^{T}$ for some $\vec{b}\in\mathcal{C}_{2}^{T}$ and some $i$. As $M$ and $M^{\prime}$ anticommute,

[TABLE]

and clearly $\vec{b}^{T}T^{T}\neq\vec{0}$. Also, $\vec{b}^{T}T^{T}H_{1}=\vec{b}^{T}H_{2}S^{T}=\vec{0}^{T}$ and so $T\vec{b}$ is a nonzero vector in $\ker(H_{1}^{T})=\mathcal{C}_{1}^{T}$. Thus, $|M|\geq|T|\geq|T\vec{b}|\geq d_{1}^{T}$.

From these two cases, we conclude

[TABLE]

If we go through the analogous argument for nontrivial $Z$-type logical operators, we would find their weight bounded below by $d_{1}$ in the case that one of $\mathcal{C}_{1}^{T}$ or $\mathcal{C}_{2}^{T}$ is trivial and $\min(d_{1},d_{2}^{T})$ otherwise. Thus, the code distance of the hypergraph product code is

[TABLE]

By looking at $L_{X}$ and $L_{Z}$, Eqs. (117) and (121), we see that there are indeed logical operators saturating this inequality, and so we have verified Eq. (64).

We conclude this appendix by reviewing the surface code as a special case of the hypergraph product. In fact, there are two versions of the surface code that can be made: the one with boundary Bravyi and Kitaev (1998) and the one on a torus Kitaev (2003).

Example 3**.**

The surface code with boundary Bravyi and Kitaev (1998) is an $\llbracket n^{2}+(n-1)^{2},1,n\rrbracket$ code. These parameters match those of $\text{HGP}(H_{R},H_{R})$. Indeed, we draw some of the stabilizers indicated by rows of $S_{X}$ and $S_{Z}$ in Fig. 6(a), in which one can recognize the surface code.

Example 4**.**

The surface code on a torus Kitaev (2003) is a $\llbracket 2n^{2},2,n\rrbracket$ code, matching the parameters of $\text{HGP}(H_{R}^{\prime},H_{R}^{\prime})$ for

[TABLE]

This is an over-complete parity check matrix for the $[n,1,n]$ classical repetition code – the sum of all rows is $\vec{0}$. Notice the transpose code is also the $[n,1,n]$ repetition code. We draw some of the stabilizers corresponding to rows of $S_{X}$ and $S_{Z}$ in Fig. 6(b) in which one can recognize the surface code on the torus.

Appendix B Expander codes

Constructions of good families of classical LDPC codes based on expander graphs are known. In this section, we review the segment of expander theory that is needed to prove the goodness of these codes, and therefore the goodness of Bravyi-Bacon-Shor codes constructed from them. All of this section is classical and we expect to do no more than inform any uninitiated readers of what is already known.

B.1 Construction

The objects used to construct good classical LDPC codes are called lossless-expanders Capalbo et al. (2002), though we will refer to them simply as expanders. Mathematically, these expanders are undirected, bipartite graphs, which we will represent by a tuple $(L,R,E)$ of left nodes, right nodes, and edges. A node $v$ has a degree, the number of edges incident to it, which we denote $\deg{v}$. Given a set of nodes $V\subseteq L\cup R$, we can talk about its set of neighbors

[TABLE]

Expanders attempt to maximize the size of $\Gamma(S)$ for all $S\subseteq L$ sufficiently small.

Definition 12** (Expanders).**

A $(n,m,b,\delta,\epsilon)$ expander is a bipartite graph $(L,R,E)$ satisfying

1. Size: $|L|=n$, $|R|=m$,
2. Degree: $\forall v\in L$, $\deg(v)=b$, $\forall w\in R$, $\deg(w)=c=nb/m$,
3. Expansion: $\forall S\subseteq L$ s.t. $|S|\leq(1-\delta)n$, $(1-\epsilon)b|S|\leq|\Gamma(S)|\leq b|S|$.

In particular, expanders with smaller $\delta$ and $\epsilon$ are better than those with larger values. The expansion property is trivial if $\delta>1-2/n$ for instance. Moreover, if $\delta\leq 1-2/n$ and $\epsilon=0$, only the graph with $m=nb$ right-nodes and $n$ connected components suffices to meet the definition. Finally, $b=1$ or $c=nb/m=1$ lead to similar trivialities. Thus, we take $\delta\leq 1-2/n$, $\epsilon>0$, and $b,c>1$ throughout.

From the definition, one can prove other facts about expanders. One very useful fact for us concerns the size of the set of “unique” neighbors of $V\subseteq L$,

[TABLE]

Elements of $\Gamma_{1}(V)$ are the elements of $\Gamma(V)$ that have just one neighbor in $V$.

Lemma 13**.**

Suppose the bipartite graph $(L,R,E)$ is an $(n,m,b,\delta,\epsilon)$ expander and $S\subseteq L$ satisfies $|S|\leq(1-\delta)n$. Then

[TABLE]

Proof.

The number of edges leaving $S$ is $b|S|$. This is the same as the number of edges entering $S$ from $\Gamma(S)$. The nodes in $\Gamma_{1}(S)\subseteq\Gamma(S)$ have exactly 1 such edge, while those in $\Gamma_{\geq 2}(S)=\Gamma(S)-\Gamma_{1}(S)$ have at least 2 such edges. Thus,

[TABLE]

where the last inequality uses the expansion property. ∎

To create a classical code from an expander, we will use (the simplest version of) Tanner’s construction Tanner (1981). This prescribes that we view the left nodes $L$ as a set of code bits and each right node as specifying a parity check on the bits that are its neighbors. More precisely, define the incidence matrix $\Lambda\in\mathbb{F}_{2}^{|L|\times|R|}$ of a bipartite graph $G=(L,R,E)$ as

[TABLE]

Then, $H=\Lambda^{T}$ takes the role of a parity check matrix to define the Tanner code of $G$, $\mathcal{C}_{G}=\ker(H)$.

If $G$ is an expander, we call $\mathcal{C}_{G}$ an expander code. In this case, we can place useful bounds on its code parameters.

Lemma 14**.**

Suppose $G=(L,R,E)$ is an $(n,m,b,\delta,\epsilon)$ expander with $\epsilon<1/2$. Then $\mathcal{C}_{G}$ is a $[n,k,d]$ code with $k\geq n-m$ and $d\geq 2(1-\epsilon)\lfloor(1-\delta)n\rfloor$.

Proof.

The parity check matrix $H$ of $\mathcal{C}_{G}$ has $m$ rows, and thus its kernel is at least $n-m$ dimensional. So, $k\geq n-m$.

Let $\vec{s}\in\mathbb{F}_{2}^{n}$ be a bit string and $S=\{v:\vec{s}_{v}=1\}\subseteq L$ be its support. We show that if $|\vec{s}|=|S|<2(1-\epsilon)\lfloor(1-\delta)n\rfloor$, then there must be a parity check unsatisfied by $\vec{s}$, and so $\vec{s}$ is not a codeword. To do this, it is sufficient to show that $\Gamma_{1}(S)$ is not empty – any $w\in\Gamma_{1}(S)$ cannot be a satisfied check as only a single bit in the check is 1.

Suppose first that $|S|\leq(1-\delta)n$. Then by Lemma 13, we have $|\Gamma_{1}(S)|\geq(1-2\epsilon)b|S|>0$, using the assumption $\epsilon<1/2$.

Now suppose $(1-\delta)n<|S|<2(1-\epsilon)\Delta$ where $\Delta=\lfloor(1-\delta)n\rfloor$. Let $T\subseteq S$ satisfy $|T|=\Delta$. So,

[TABLE]

by Lemma 13. At the same time $|S-T|=|S|-|T|<(1-2\epsilon)\Delta<\Delta$ implies

[TABLE]

because nodes in $S-T$ are degree $b$. A check $w$ is in $\Gamma_{1}(S)$ if $w\in\Gamma_{1}(T)$ and $w\not\in\Gamma(S-T)$. Since $|\Gamma_{1}(T)|>|\Gamma(S-T)|$ by Eqs. (142), (143), we have $|\Gamma_{1}(S)|>0$. ∎

It is worth noting when a family of expander codes $[n,k,d]$ is good, i.e. $k=\Theta(n)$ and $d=\Theta(n)$. Using Lemma 14, it is sufficient that $\epsilon,\delta$ are constant (independent of $n$) and that $m/n=b/c$ is constant. It is typical to construct families in which $b$ (the degree of nodes on the left) and $c$ (the degree of nodes on the right) are both constant individually. This makes the code a low-density parity check code and also enables the efficient decoder discussed in the next section.

Lemma 14 assumes $\epsilon<1/2$ which means it is only sufficient for analyzing expander codes constructed from expanders with sufficiently large expansion. For a long time, although expanders of arbitrarily large size with $\epsilon<1/2$ were known to exist by counting, it was not known how to construct them. However, the zig-zag construction Capalbo et al. (2002) eventually solved this problem. For our purposes, a suitable distillation of their result is the following.

Theorem 15** (Hoory, Linial, Wigderson Hoory et al. (2006), Thm. 10.4).**

For every $\epsilon>0$ and $\alpha\in(0,1)$, there exist constants $\gamma,\sigma$ and an explicit family of $(n,m,b,\delta,\epsilon)$ expanders with $m=\alpha n$,

[TABLE]

Using Lemma 14, the corresponding expander codes have parameters $[n,k,d]$ with

[TABLE]

Theorem 15 is a theoretically important result – it provides a construction of a good family of classical codes, and moreover the parity checks involve only constant numbers of bits. However, the constants involved may not be the most practical, and random instances of bipartite graphs, like those analyzed in the Appendix of Sipser and Spielman (1996) or in Theorem 8.7 of Richardson and Urbanke (2008), may be less cumbersome to work with.

B.2 Decoding

Sipser and Spielman Sipser and Spielman (1996) analyzed a decoder for classical expander codes that operates in greedy fashion by flipping any bits that overall reduce the number of unsatisfied parity checks. We will refer to this as the flip decoder. They show that for expanders with sufficiently large expansion ($\epsilon<1/4$) the flip decoder corrects any number of errors within a constant fraction of the code distance and does so in time proportional to the code size, i.e. in linear time. Later Spielman Spielman (1996) analyzed the flip decoder in the scenario that the parity checks are noisy in addition to the bits. It is this latter scenario that is most relevant to the quantum case where we may only noisily measure parity checks and not the data qubits themselves. We provide a somewhat generalized presentation of Spielman’s analysis here. In particular, we show that for expanders with larger expansion (smaller $\epsilon$) the flip decoder deals with measurement errors better.

Let $\hat{e}_{i}$ denote the vector with elements $(\hat{e}_{i})_{j}=\delta_{ij}$. Here it represents a flip of the $i^{\text{th}}$ bit. The flip decoder is defined as follows.

Definition 16** (Sipser-Spielman Flip Decoder Sipser and Spielman (1996); Spielman (1996)).**

Given an expander code $\mathcal{C}$ with parity check matrix $H\in\mathbb{F}_{2}^{m\times n}$ and a vector indicating unsatisfied checks $\vec{u}\in\mathbb{F}_{2}^{m}$, return a set of corrections $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}\in\mathbb{F}_{2}^{n}$ by doing the following.

1. (1)

Initialize $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}=0^{n}$ and $\vec{u}\mkern 2.0mu\vphantom{u}^{\prime}=\vec{u}$. 2. (2)

Repeat

1. (a)

Find $i\in\{1,2\dots,n\}$ such that $|\vec{u}\mkern 2.0mu\vphantom{u}^{\prime}|>|H\hat{e}_{i}-\vec{u}\mkern 2.0mu\vphantom{u}^{\prime}|$. If none exists, return $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}$. 2. (b)

Let $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}\leftarrow\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}+\hat{e}_{i}$ and $\vec{u}\mkern 2.0mu\vphantom{u}^{\prime}\leftarrow H\hat{e}_{i}-\vec{u}\mkern 2.0mu\vphantom{u}^{\prime}$.

Steps (2a) and (2b) constitute a decoding “round”.

Since the number of unsatisfied checks $|\vec{u}^{\prime}|$ decreases each round and there are $O(n)$ checks in a $[n,k,d]$ expander code, it is somewhat reasonable to believe that this decoder takes linear time.

Lemma 17** (Sipser and Spielman Sipser and Spielman (1996)).**

Let $\mathcal{C}$ be an $[n,k,d]$ expander code based on an $(n,m,b,\delta,\epsilon)$ expander graph with $b$ and $m/n$ constant. The flip decoder for $\mathcal{C}$ runs in time $O(n)$.

Proof.

Proving this simply requires a suitable data structure. We assume that the adjacency matrix of the expander (or equivalently the check matrix of the code) is given in a sparse matrix representation, so it takes constant time to obtain a list of neighbors of a bit or check in the expander graph.

Recall $\vec{u}\in\mathbb{F}_{2}^{m}$ is given as the value of the $m$ parity checks. At the beginning of the decoding, we calculate for each bit $i$ the number $v_{i}$ of unsatisfied checks that it is involved in. This takes $O(bn)=O(n)$ total time. We construct $b+1$ linked lists, one for each possible value of $v_{i}$, and place each $i$ in the corresponding list. That is, for each $i\in\{1,2,\dots,n\}$, we store $\{i,v_{i},p_{i},n_{i}\}$, where $p_{i},n_{i}\in\{1,2,\dots,n\}$ point to the previous and next elements in the linked list (or are null if $i$ is at the head or tail). Variables $h_{v}\in\{1,2,\dots,n\}$ for every $v\in\{0,1,\dots,b\}$ point to the linked list heads (or null if the list is empty). The initial setup of $p_{i}$, $n_{i}$, and $h_{v}$ values takes $O(n)$ time. It is also important to note that removing from and attaching to the front of linked lists take $O(1)$ time.

The main body of the flip decoding algorithm is the iteration in Step (2) of Definition 16. Since the number of unsatisfied clauses strictly decreases during each round, there are at most $O(m)=O(n)$ rounds. Moreover, each round can be made to take constant time, as we now show.

Every round the algorithm begins by finding the non-null $h_{v}$ with largest $v$. This takes $O(b)$ time. If $0\leq v\leq b/2$, then there is no bit to flip to reduce the number of unsatisfied clauses and the algorithm returns. If $v>b/2$, then flip bit $h_{v}$. This causes $b=O(1)$ checks $j$ to flip and we update the values $u_{j}$ accordingly. Within each of the flipped checks are $c=O(1)$ bits $i$ which now participate in either one more or one fewer unsatisfied check. The values $v_{i}$ should be updated accordingly and the linked list element $\{i,v_{i},p_{i},n_{i}\}$ removed from its current linked list and inserted at the head of list $h_{v_{i}}$, which takes $O(1)$ time. Thus, the entire round takes $O(1)$ time. ∎

Presently, we concern ourselves with how well the decoder corrects errors. The main result is that the number of errors on the data can be reduced to a constant fraction of the number of errors on the checks.

Theorem 18** (Spielman Spielman (1996)).**

Let $\mathcal{C}$ be an expander code constructed from a $(n,m,b,\delta,\epsilon)$ expander with $\epsilon<\frac{1}{4}-\frac{r}{b}$ for $1\leq r<b/4$. Given input $\vec{u}=H(\vec{s}_{0}+\vec{e})+\vec{f}$ for $\vec{s}_{0}\in\mathcal{C}$ and provided

[TABLE]

the noisy flip decoder returns $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}$ such that $|\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}-\vec{e}|<|\vec{f}|/r$.

Proof.

Let $E=\{i:\vec{e}_{i}+\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}_{i}=1\}$ be the set of corrupted message bits and $U=\{j:\vec{u}\mkern 2.0mu\vphantom{u}^{\prime}_{j}=1\}$ be the set of unsatisfied checks at any point during execution of the algorithm. Let $S=\Gamma(E)-U$ be the satisfied checks in the neighborhood of $E$. Provided $|E|=|\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}-\vec{e}|\leq(1-\delta)n$, the expansion property implies

[TABLE]

This gives a lower bound on $|U|$ and $|S|$.

We can get an upper bound on these by a counting argument. Imagine we add $m$ additional nodes to the left side of the bipartite expander graph and connect these new nodes pairwise to the corresponding $m$ check nodes on the right side. These new nodes represent the presence (if set to $1$) or absence (if set to [math]) of an error on the check bit. So, of these new nodes, $|\vec{f}|$ are set to 1, those in the set $F=\{j+n:\vec{f}_{j}=1\}$. Now every check in $U$ is connected to at least one node in $E\cup F$ and every check in $S$ is connected to at least two nodes in $E\cup F$. Since there are $b|E|+|\vec{f}|$ edges leaving $E\cup F$, we have

[TABLE]

Combine Eqs. (149), (150) to get

[TABLE]

or, removing $|S|$ entirely and using $\epsilon<\frac{1}{4}-\frac{r}{b}$,

[TABLE]

Thus, if $|\vec{f}|/r\leq|E|\leq(1-\delta)n$, then

[TABLE]

If $u_{x}=|\Gamma(x)\cap U|$ for $x\in E$ is the number of unsatisfied checks that $x$ participates in, then clearly

[TABLE]

or, simply,

[TABLE]

implying that there exists $y\in E$ such that $u_{y}>b/2$. Thus, there is always a bit to flip in step (2a) provided $|\vec{f}|/r\leq|E|\leq(1-\delta)n$.

We complete the proof by showing that $|E|\leq(1-\delta)n$ always holds and therefore the flip algorithm only finishes if $|E|=|\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}-\vec{e}|<|\vec{f}|/r$.

The noisy flip algorithm flips one bit at a time and $|E|<\lfloor(1-\delta)n\rfloor$ at the beginning of the algorithm, so if $|E|>(1-\delta)n$ at some time, then there is a prior time at which $|E|=\lfloor(1-\delta)n\rfloor$. Then, we can apply Eq. (152) to find

[TABLE]

Let $U_{0}$ denote $U$ at the very start of the algorithm (i.e. when $\vec{e}\mkern 2.0mu\vphantom{e}^{\prime}=0^{n}$ and $|E|=|\vec{e}|$). By Eq. (150), we see

[TABLE]

Moreover, the intermediate rounds of the algorithm always decrease the size of $U$. So, $|U_{0}|>|U|$ and hence

[TABLE]

However, this is in contradiction with Eq. (148). ∎

We briefly remark that although $(1-2\epsilon)\lfloor(1-\delta)n\rfloor<d/2$ by Lemma 14, it is not much less than the lower bound on $d/2$ from that lemma. The difference is the factor $(1-2\epsilon)/(1-\epsilon)$, which is constant and near unity when $\epsilon$ is constant and small. Also, since $|\vec{e}|+|\vec{f}|\geq|\vec{e}|+\frac{2}{b}|\vec{f}|$, the assumption

[TABLE]

is a weaker replacement for Eq. (148), but one that makes the total number of errors $|\vec{e}|+|\vec{f}|$ more prominent.

This theorem implies that errors can be kept at a manageable level over time. A simple model of data storage is one in which we periodically error correct based on noisy readout of the parity checks, and noise on the data occurs in between these corrections. Suppose at most $|\vec{e}|$ errors occur on the data between corrections and during correction at most $|\vec{f}|$ parity checks are misread. Then, after correction, Theorem 18 guarantees at most $|\vec{f}|/r$ errors remaining on the data. These errors combine with the $|\vec{e}|$ data errors in the next step. Thus, a steady state is achieved – following any correction the data has at most $|\vec{f}|/r$ errors provided that

[TABLE]

It is sufficient (though weaker) for

[TABLE]

In this classical scenario, assuming constant error rates, $|\vec{e}|$ and $|\vec{f}|$ both scale linearly with $n$ and so this condition is realistically achievable, even asymptotically.

Appendix C Proof of Lemma 9

A subsystem code’s distance is the minimum weight of a dressed logical operator. Thus, to show $D(\mathcal{G}^{\prime})\geq D(\mathcal{G})$, we just need to show $\hat{\mathcal{L}}(\mathcal{G}^{\prime})\leq\hat{\mathcal{L}}(\mathcal{G})$. As $\mathcal{G}^{\prime}$ is a gauge-fixing of $\mathcal{G}$, we have that $\mathcal{S}(\mathcal{G})\leq\mathcal{S}(\mathcal{G}^{\prime})\leq\mathcal{G}^{\prime}\leq\mathcal{G}$ and $K(\mathcal{G})=K(\mathcal{G}^{\prime})$.

Notice first that $\mathcal{L}(\mathcal{G})\leq\mathcal{L}(\mathcal{G}^{\prime})$ because anything that commutes with all elements of $\mathcal{G}$ also commutes with all elements of $\mathcal{G}^{\prime}\leq\mathcal{G}$. Second, elements of $\mathcal{S}(\mathcal{G}^{\prime})-\mathcal{S}(\mathcal{G})$ are not in $\mathcal{L}(\mathcal{G})$, and so the quotient groups $\mathcal{L}(\mathcal{G})/\mathcal{S}(\mathcal{G})$ and $\mathcal{L}(\mathcal{G})/\mathcal{S}(\mathcal{G}^{\prime})$ are isomorphic. Thus, combine these two observations to get

[TABLE]

However, $K(\mathcal{G})=K(\mathcal{G}^{\prime})$ dictates that $|\mathcal{L}(\mathcal{G})/\mathcal{S}(\mathcal{G})|=|\mathcal{L}(\mathcal{G}^{\prime})/\mathcal{G}^{\prime}|$ so

[TABLE]

Because $\mathcal{S}(\mathcal{G})\leq\mathcal{G}$ and $\mathcal{S}(\mathcal{G}^{\prime})\leq\mathcal{G}^{\prime}$,

[TABLE]

Using Eq. (163) and the fact that $\mathcal{G}^{\prime}\leq\mathcal{G}$, we get $\hat{\mathcal{L}}(\mathcal{G}^{\prime})\leq\hat{\mathcal{L}}(\mathcal{G})$, completing the proof.