Dimensional jump in quantum error correction

A stabilizer subsystem code [13] on n physical qubits is defined by two subgroups ${ \mathcal S },{ \mathcal G }$ of the Pauli group of operators on n qubits. The stabilizer group ${ \mathcal S }$ defines the code subspace where quantum information is encoded: encoded states are eigenstates, with eigenvalue +1, of all the elements of ${ \mathcal S }$. The gauge group ${ \mathcal G }$ generates the algebra of operators that do not disturb encoded information. The groups ${ \mathcal S }$ and ${ \mathcal G }$ satisfy

$$\begin{eqnarray}&&-1\;\not\hspace{-2pt}{\in }\;{ \mathcal S },\qquad { \mathcal S }\propto { \mathcal G }\cap { \mathcal Z }({ \mathcal G }),\end{eqnarray} \tag{ 1 }$$

where ${ \mathcal Z }({ \mathcal A })$ denotes the centralizer of ${ \mathcal A }$ in the Pauli group. The operators in the group ${ \mathcal Z }({ \mathcal G })$ are (bare) logical (Pauli) operators: they transform encoded states while preserving the code subspace. Logical operators that are equivalent up to stabilizers have the same action on encoded qubits. Therefore it is convenient to choose a representative group of logical operators ${ \mathcal L }\subseteq { \mathcal Z }({ \mathcal G })$ such that each element of ${ \mathcal L }$ belongs to a different class of the quotient ${\text{}}{ \mathcal Z }({ \mathcal G })/{\text{}}{ \mathcal S }$.

Error correction is the procedure that attempts to remove the errors that a code has suffered. Ideally it amounts to

• (a)  
  measure a set of generators of ${ \mathcal S }$ (the result is the syndrome σ of ${ \mathcal S }$), and
• (b)  
  apply a Pauli operator E that yields an encoded state (such E is said to have syndrome σ).

The operator E anticommutes with the generators with negative eigenvalue outcome. Its choice should minimize residual logical errors.

When the stabilizer generators are local the above ideal process is quantum-local. However, in practice error correction is itself noisy, and often in making the process fault-tolerant quantum-locality is lost. Surprisingly, for some codes quantum-locality can be preserved: they allow single-shot error correction [11].

Gauge fixing is a procedure [14] that allows to switch back and forth between two codes ${ \mathcal S },{ \mathcal G }$ and ${{ \mathcal S }}^{\prime },{{ \mathcal G }}^{\prime }$ if [10] they share a representative group of logical operators ${ \mathcal L }$ and

$$\begin{eqnarray}&&{ \mathcal S }\subseteq {{ \mathcal S }}^{\prime }\end{eqnarray} \tag{ 2 }$$

or, equivalently (up to a choice of signs for ${ \mathcal S }$ and ${ \mathcal S }^{\prime}$)

$$\begin{eqnarray}&&{{ \mathcal G }}^{\prime }\subseteq { \mathcal G }.\end{eqnarray} \tag{ 3 }$$

Any encoded state of ${{ \mathcal S }}^{\prime }$ is also an encoded state for ${ \mathcal S }$. Transforming an encoded state of ${ \mathcal S }$ into an encoded state of ${{ \mathcal S }}^{\prime }$ is called gauge fixing. The procedure is similar to error correction: ideally it amounts to

• (a)  
  extract the syndrome σ of ${{ \mathcal S }}^{\prime }$, and
• (b)  
  apply some operator $E\in { \mathcal G }$ with syndrome σ.

The syndrome σ is trivial for elements of ${ \mathcal S }$, and E is unique up to elements of ${{ \mathcal G }}^{\prime }$.

As a particular case of gauge fixing, consider that the code ${{ \mathcal S }}^{\prime }$, ${{ \mathcal G }}^{\prime }$ actually consists of several codes with gauge groups ${{ \mathcal S }}_{i}$, ${{ \mathcal G }}_{i}$ defined on disjoint sets of n_i qubits each. Together they form the code on $n={\sum }_{i}{n}_{i}$ qubits

$$\begin{eqnarray}&&{{ \mathcal S }}^{\prime }=\displaystyle \prod _{i}{{ \mathcal S }}_{i},\qquad {{ \mathcal G }}^{\prime }=\displaystyle \prod _{i}{{ \mathcal G }}_{i},\end{eqnarray} \tag{ 4 }$$

where it is implicitly assumed that all operators have been suitably tensored with identities to act on the n qubits. If the codes have logical representative groups ${{ \mathcal L }}_{i}$, we might choose for the n qubit code the group

$$\begin{eqnarray}&&{ \mathcal L }:= \displaystyle \prod _{i}{{ \mathcal L }}_{i}.\end{eqnarray} \tag{ 5 }$$

Any code ${ \mathcal S }$, ${ \mathcal G }$ on the n qubits that has logical group ${ \mathcal L }$ and satisfies conditions (2, 3) can be gauge fixed to ${{ \mathcal S }}^{\prime }$, ${{ \mathcal G }}^{\prime }$ (at least ideally). In this case gauge fixing amounts to splitting the n-qubit code into several pieces, each with some of the original physical and logical qubits. Conversely, putting together the pieces yields an encoded state of ${ \mathcal S }$, ${ \mathcal G }$.

2D color codes [6] are defined on two-colexes. These are 2D trivalent lattices with three-colored edges in which plaquettes (two-cells) have edges of two colors. The two-colexes considered here are triangular. In particular, each side of the triangle has edges in different combinations of two colors, see figure 2. A plaquette with red and green edges is a rg-plaquette, a blue edge is a b-edge, etc.

Zoom In Zoom Out Reset image size

3D color codes [5] are defined on three-colexes. These are 3D tetravalent lattices with four-colored edges, in which plaquettes have edges of two colors and cells (three-cells) have edges of three colors. The three-colexes considered here as a starting point are tetrahedral. In particular, each facet of the tetrahedron has edges in different combinations of three colors, see figure 2.

In the present work the specific choice of two- and three-colexes is not relevant. For detailed constructions and pictures, the reader is referred to the literature [5, 10, 12, 15, 16].

2D color codes and 3D gauge color codes [10] are self-dual CSS topological stabilizer codes, i.e. the generators of the stabilizer and gauge group are products either exclusively of bit-flip X operators or exclusively of phase-flip Z operators, with the same geometry for X- and Z-type generators. Therefore, the code is completely defined by the support of the generators.

Both in 2D and 3D there is one physical qubit per vertex of the colex. Denote the respective stabilizer and gauge groups ${{ \mathcal S }}_{2},{{ \mathcal G }}_{2}$ and ${{ \mathcal S }}_{3},{{ \mathcal G }}_{3}$. Let the support of an edge, plaquette or cell operator be the set of vertices of a given edge, plaquette or cell, respectively. E.g. a plaquette operator X_p flips the qubits of the plaquette p, and so on. Both ${{ \mathcal G }}_{2}$ and ${{ \mathcal G }}_{3}$ are generated by the set of all plaquette operators, something that will be highly relevant below. The stabilizers in general depend on the geometry of the code. In 2D triangular codes plaquette operators generate ${{ \mathcal S }}_{2}$, and in 3D tetrahedral codes cell operators generate ${{ \mathcal S }}_{3}$. In both cases the support of X and Z logical operators can be chosen to be the set of all qubits.

It is interesting to mention that error correction has been substantially explored for 2D color codes [17–24], whereas for 3D little is known [12].

The starting point is a geometrical observation: each triangular facet of a tetrahedral three-colex is a triangular two-colex. Assume that such a three-colex and a distinguished facet are given. This facet will be denoted the outer (two-)colex. Conversely, the inner (three-)colex is composed of those vertices, edges, and cells not in contact with the outer colex. Cells/plaquettes with both inner and outer vertices are called interface cells/plaquettes.

The three-colex yields a 3D gauge color code ${{ \mathcal S }}_{3},{{ \mathcal G }}_{3}$, and the outer colex yields a 2D color code ${{ \mathcal S }}_{2},{{ \mathcal G }}_{2}$. Crucially for the results below, the 3D code admits logical operator representatives with support the set of all outer qubits, see appendix A. That is, the 3D gauge color code and the 2D color code have a common group ${ \mathcal L }$ of logical operator representatives.

A 3D gauge color code ${{ \mathcal S }}_{{\rm{in}}},{{ \mathcal G }}_{{\rm{in}}}$ can also be defined for the inner colex. Plaquette operators generate ${{ \mathcal G }}_{{\rm{in}}}$ (by definition) and ${{ \mathcal S }}_{{\rm{in}}}$ is generated by (i) cell operators and (ii) the restriction to the inner qubits of interface cell operators. The resulting code encodes no logical qubits, see appendix A.

As observed above, (i) the inner code has no logical qubits, (ii) the outer 2D code and the 3D code share representative logical operators and (iii)

$$\begin{eqnarray}&&{{ \mathcal G }}_{2}\;{{ \mathcal G }}_{{\rm{in}}}\subseteq {{ \mathcal G }}_{3}.\end{eqnarray} \tag{ 6 }$$

According to section 2.4 (with ${ \mathcal G }={{ \mathcal G }}_{3}$ and ${{ \mathcal G }}^{\prime }={{ \mathcal G }}_{2}{{ \mathcal G }}_{{\rm{in}}}$) the 3D code splits via gauge fixing in two pieces: the outer 2D code (that keeps the logical qubit) and the inner code. Moreover, due to the CSS structure (2) holds exactly, not up to a choice of signs:

$$\begin{eqnarray}&&{{ \mathcal S }}_{3}\subseteq {{ \mathcal S }}_{2}\;{{ \mathcal S }}_{{\rm{in}}}.\end{eqnarray} \tag{ 7 }$$

Denote by ${{ \mathcal G }}_{3}{| }_{2}$ the group formed by the operators in ${{ \mathcal G }}_{3}$ constrained to the outer qubits. Its generators are edge operators, the restriction of interface plaquettes to the outer code. Ideally, the dimensional jump from the 3D code to the 2D code amounts to

• (1)  
  discard inner qubits,
• (2)  
  extract the syndrome σ of ${{ \mathcal S }}_{2}$, and
• (3)  
  apply some $E\in {{ \mathcal G }}_{3}{| }_{2}$ with syndrome σ.

The operator E is unique up to elements of ${{ \mathcal S }}_{2}$ and is a product of string operators. E.g. a b-string s is composed of outer b-edges e_i and might have endpoints at outer rg-plaquettes, see figure 3. The string operator X_s flips the qubits of the edges e_i and anticommutes with a plaquette operator Z_p if and only if p is an endpoint of s.

Zoom In Zoom Out Reset image size

The above procedure is not fault-tolerant, no matter how the syndrome σ is extracted: even if the gauge fixing process is perfect, most pre-existing single-qubit errors on outer qubits yield a residual logical error. To achieve fault-tolerance the key is to extract σ indirectly from the inner qubits. The resulting gauge fixing process is not only fault-tolerant but also quantum-local.

Let the outer colex be the rgb-facet of the tetrahedron, i.e. the facet with r-, g- and b-edges on it. Suppose that inner rg-plaquette Z_p operators are measured on an encoded state of ${{ \mathcal S }}_{3}$. Each plaquette has a dual edge that pierces the plaquette connecting the centers of the cells meeting at the plaquette. The result of the measurement is codified as the set γ of edges dual to the inner rg-plaquettes with eigenvalue –1.

Given a cell c with rg-plaquettes p_i, every vertex in c belongs to exactly one of the p_i. Therefore

$$\begin{eqnarray}&&{Z}_{{\rm{c}}}=\displaystyle \prod _{i}{Z}_{{{\rm{p}}}_{i}}.\end{eqnarray} \tag{ 8 }$$

For the initial state ${Z}_{{\rm{c}}}=1$ and thus γ has no inner endpoints, i.e. inner cells at which an odd number of edges meet. Therefore γ is a disjoint union of paths ${\gamma }_{i}$, or 'flux-lines', that are either closed or have endpoints (i) at the rgy-facet or (ii) at an interface rgy-cell, see figure 3.

Every interface rgy-cell c has a unique outer rg-plaquette p_c (the rest are inner, unless the colex is pathological), see figure 3. A flux-line is said to have an endpoint at p_c when it has an endpoint at c. According to (8) ${\text{}}{Z}_{{{\rm{p}}}_{c}}$ has eigenvalue −1 if and only if p_c is the endpoint of and odd number of flux-lines ${\gamma }_{i}$. Thus the syndrome of ${{ \mathcal S }}_{2}$ can be recovered from the measurement of inner rg-, gb- and rb-plaquette X and Z operators, which commute² , see appendix A. The steps (1) and (2) above can be substituted by:

• Obtain a syndrome σ from the destructive measurement of the plaquette operators in ${{ \mathcal G }}_{{\rm{in}}}$ with colors matching the outer plaquettes.

Consider again the measurement of inner rg-plaquette Z_p operators. Suppose that the original encoded state is noiseless but measurements can fail: instead of the correct dual edge set γ they yield $\gamma +\delta$, with + the symmetric difference of sets: plaquette operators corresponding to edges in δ are assigned the wrong eigenvalue. The set $\gamma +\delta$ can have inner endpoints. Let ${\delta }_{0}$ be a set of dual edges of minimal cardinality with the same inner endpoints (efficiently computable using perfect matching [2]). It provides an 'effective' set

$$\begin{eqnarray}&&{\gamma }_{\mathrm{eff}}:= \gamma +\delta +{\delta }_{0}=\gamma +\underset{i}{\bigsqcup }{\omega }_{i},\end{eqnarray} \tag{ 9 }$$

where $\delta +{\delta }_{0}$ decomposes as a disjoint union of flux-lines ${\omega }_{i}$ (because $\delta +{\delta }_{0}$ has, like ${\gamma }_{\mathrm{eff}}$, no inner endpoints).

For every outcome γ of rg-flux-lines there is some operator ${E}_{\gamma }$ that is a product of b-string X operators and has the syndrome corresponding to γ; it is unique up to stabilizers. By using ${\gamma }_{\mathrm{eff}}$ as input for the third gauge fixing step, instead of the correct operator E_γ we apply

$$\begin{eqnarray}&&{E}_{{\gamma }_{\mathrm{eff}}}\sim {E}_{\gamma }\;{E}_{\delta +{\delta }_{0}}\sim {E}_{\gamma }\;\displaystyle \prod _{i}{E}_{{\omega }_{i}},\end{eqnarray} \tag{ 10 }$$

where the equivalence is up to stabilizers: measurement noise δ translates into errors ${E}_{{\omega }_{i}}$ at the final stage.

How bad are these errors? Each ${E}_{{\omega }_{i}}$ is a b-string operator ${\text{}}{X}_{{\text{}}{s}_{i}}$ that we can choose subject to the constraint that its endpoints on outer plaquettes should match those of ${\omega }_{i}$. It follows by inspection of the different geometries, depicted in figure 3, that the number of qubits in the support of ${E}_{{\omega }_{i}}$ is, up to a constant depending on the lattice structure, smaller than the length $| {\omega }_{i}|$ of the flux-line. Moreover, at least half of the edges of ${\omega }_{i}$ belong to δ, rather than ${\delta }_{0}$:

$$\begin{eqnarray}&&| {\delta }_{0}+{\omega }_{i}| =| {\delta }_{0}| -| {\omega }_{i}\cap {\delta }_{0}| +| {\omega }_{i}\cap \delta | \geqslant | {\delta }_{0}| \end{eqnarray} \tag{ 11 }$$

because ${\delta }_{0}+{\omega }_{i}$ has the same inner endpoints as ${\delta }_{0}$. Thus an error ${E}_{{\omega }_{i}}$ of large support requires a large ${\omega }_{i}$ within which at least $| {\omega }_{i}| /2$ measurements fail. This suggests that local noise in the measurement process will yield local residual noise. Indeed, a standard argument [2, 11] shows that if the noise is local and below a threshold, so will be the residual noise, see appendix B.

In general the original 3D state will be noisy, and so will be the measurements and the application of $E\in {{ \mathcal G }}_{3}{| }_{2}$. Local errors affecting outer qubits at any time will remain local, because the application of E is local. Local errors affecting inner qubits and previous to measurements can be absorbed as local measurement errors. If all the noise is local and below a threshold, so will be the residual noise after the 'dimensional collapse'.

The inverse dimensional jump only requires initializing the inner code. Since it encodes no logical qubits, it suffices to apply error correction to an arbitrary state of the inner qubits. Moreover, since it is a 3D gauge color code with local stabilizer and gauge generators it admits single-shot error correction, see appendix A, and thus the process is quantum-local.

Colexes and gauge color codes can be defined for arbitrary dimensions [10]. For a given D-colex it is possible to build different color codes with labels (d, e) that indicate the dimension of the gauge generators: d and e are positive integers with $d+e\leqslant D$, X-type generators are $(e+1)$-cell operators, and Z-type generators are $(d+1)$-cell operators.

The most interesting class of color codes is that constructed out of simplicial colexes, which generalize the triangular and tetrahedral colexes considered above. They encode a single qubit, and the logical X and Z operators can be chosen to have as support the whole colex. For these codes gauge fixing can be used to change, within a given colex, the parameters (d, e) at will [10].

The dimensional jump described above switches between a given $(1,1)$ tetrahedral color code and a $(1,1)$ triangular color code defined on any of the facets of the tetrahedron. Analogously, one can switch between a (d, e) D-simplicial color code and a (d, e) $(D-1)$-simplicial color code defined on any of the facets of the D-simplex³ . The lesson is that gauge color codes with different values of D or (d, e) are more than just separate codes. Altogether they form a system of topological stabilizer codes, and much more is possible by making them work together than by using them separately.

Finally, for every dimension D there exists a minimal simplicial colex with ${2}^{D+1}-1$ vertices [10]. The corresponding color codes are quantum Reed–Muller codes and are known to be related via gauge fixing [25].

Consider, as described above, a quantum computer where logical qubits are placed on a stack and non-trivial computations are limited to the end of the stack: the rest of qubits can only be swapped with their neighbors in the stack. It is possibly not entirely obvious that the number of rounds of parallel gates can be, up to a constant, equal to the number of gates in the circuit model. This section provides a simple algorithm for swapping the stacked logical qubits that achieves this.

At the end of the stack there are a number of (logical) qubits on which non-swap gates can be performed. At least there should be two of them, since two-qubit gates are necessary. These qubits can be regarded as the 'internal' memory of a 'processing unit', while the rest form an 'external' memory: the stack. On the stack two kinds of operations are allowed: the swap of neighboring qubits and the swap of the topmost qubit with an internal qubit.

The computation is divided in steps. At each step a certain external qubit is required to be at the end of the stack, so that it can be accessed by the processing unit. The challenge is to perform on the stack, after each computational step, a finite depth circuit composed of nearest neighbor swaps that places the next qubit to be processed at the end of the stack.

The proposed algorithm is the following. The positions in the stack are labeled with integers: position 1 is the topmost. At the sth step the position i has an integer label m_i: it indicates that the qubit currently at position i should be at position 1 on the step ${m}_{i}\geqslant s$, but not before. In particular at the sth step

$$\begin{eqnarray}&&{m}_{1}=s.\end{eqnarray} \tag{ 12 }$$

When a qubit will not be used again this label can take any value larger than the number of steps, with the condition that ${m}_{i}\ne {m}_{j}$ for $i\ne j$.

At start, before the first step, qubits are ordered according to their first use, i.e.

$$\begin{eqnarray}&&{m}_{i}\lt {m}_{i+1},\qquad {m}_{1}=1.\end{eqnarray} \tag{ 13 }$$

After the step s is performed the label m₁ is updated to its new value (the rest stay clearly the same) and the following operations are performed, each consisting of a round of parallel swaps:

• (1)  
  For every $n\geqslant 0$, if

  $$\begin{eqnarray}&&{m}_{2n+1}\gt {m}_{2n+2}\end{eqnarray} \tag{ 14 }$$

  swap the qubits at positions $2n+1$ and $2n+2$ (and the labels ${m}_{2n+1}$ and ${m}_{2n+2}$ accordingly).
• (2)  
  For every $n\geqslant 1$, if

  $$\begin{eqnarray}&&{m}_{2n}\gt {m}_{2n+1}\end{eqnarray} \tag{ 15 }$$

  swap the qubits at positions $2n$ and $2n+1$ (and the labels m_2n and ${m}_{2n+1}$ accordingly).

To check that (12) is satisfied at every step, it suffices to show that at every step and for all positions i

$$\begin{eqnarray}&&{m}_{1}\leqslant {m}_{i}.\end{eqnarray} \tag{ 16 }$$

Suppose that after the sth step and the update of m₁

$$\begin{eqnarray}&&{m}_{2n}\lt {m}_{2n+k},\qquad n,k\gt 0.\end{eqnarray} \tag{ 17 }$$

Then, after the first round of swaps is performed

$$\begin{eqnarray}&&{m}_{2n+1}\lt {m}_{2n+1+k},\qquad n\geqslant 0,k\gt 0\end{eqnarray} \tag{ 18 }$$

and after the second round of swaps is performed both (16) and (17) hold again. In particular ${m}_{1}=s+1$ as required. Thus the inequalities (17) are an invariant of the two-round procedure. Since they are initially satisfied, the algorithm works.

The tetrahedral colexes of the main text are just an example of a larger class of geometries for color codes. As in [11], of interest here are three-colexes Λ that are topological balls and are obtained by removing some vertices (and all cells in contact with them) of a larger colex $\bar{{\rm{\Lambda }}}$ without boundary. The boundary of Λ is a topological sphere divided in regions (discs), that meet at borders (open lines), that meet at corners (points). They are defined as follows. Consider a rgb-cell of $\bar{{\rm{\Lambda }}}$ that is not part of Λ but is in contact with Λ. The rgb-cell and Λ share a set of plaquettes R, which can only contain rg-, rb- or gb-plaquettes. Typically these plaquettes form a topological disc in the boundary of Λ, which is called a rgb-region (otherwise there are several discs, each a region). The r- and g-edges that separate a rgb-region and a rgy-region are said to form a rg-border. For each rg-border there is exactly one rg-plaquette in $\bar{{\rm{\Lambda }}}$ (and not in Λ) that contains its edges. Finally, when a rg-border, a rb-border and a gb-border meet at a vertex, this is said to be a y-corner of the colex. Again, for each y-corner there is exactly one y-edge in $\bar{{\rm{\Lambda }}}$ (and not in Λ) that contains it. This description of the boundary of Λ in terms of regions, borders and corners does not depend on $\bar{{\rm{\Lambda }}}$: it is intrinsic to Λ.

In the case of the tetrahedral colex each facet is a region with a different color combination: rgb, rgy, rby and gby. The simplest $\bar{{\rm{\Lambda }}}$ is obtained by adding a single additional vertex together with a single edge, plaquette and cell for each color combination. The resulting manifold is a three-sphere. Due to this construction, color codes in tetrahedral colexes have been called 'punctured'.

The inner colex described in the main text is another example of the above general class of geometries. It is obtained from a tetrahedral colex by erasing all the cells in contact with one of the facets/regions. Each of the removed cells contributes a region in the inner colex. E.g. in the main text the outer set of vertices is the rgb-facet, which is in contact with rgy-, rby- and gby-cells. To obtain the inner colex all the outer vertices are removed, together with those cells. The remaining inner colex has rgy-, rby- and gby-regions, which are of two kinds. They can correspond to one of the original facets of the tetrahedron, or they can correspond to one of the erased cells.

The regions of the tetrahedral and inner colex turn out to have very different properties at the level of the code. This motivates some definitions. A border is odd if it connects two corners with different colors. A region without odd borders is said to be frozen. A region with an odd number of odd borders of any given color is said to be free. In a tetrahedral colex all regions are free, e.g. the rgb-facet has a single odd rg-border, connecting the r- and the b-corner. In an inner colex all regions are frozen, because all corners have the same color (in the above example they are y-corners).

As stated in the main text, a 3D gauge color code is obtained by placing a qubit at each vertex of the three-colex and attaching gauge X and Z generators to plaquettes. A bit-flip plaquette operator X_p has support on the qubits belonging to the plaquette p, and similarly for a phase-flip plaquette operator Z_p. If p is a rg-plaquette then X_p can only anticommute with ${Z}_{{\rm{p}}^{\prime} }$ if ${{\rm{p}}}^{\prime }$ is a by-plaquette: e.g. if ${p}^{\prime }$ is a gb-plaquette then it shares with p a certain number x of b-edges, and then exactly $2x$ qubits (a qubit belongs at most to one b-edge).

For the above class of geometries, it is shown in [11] that the generators of ${ \mathcal Z }({ \mathcal G })$ are (i) cell operators and (ii) region operators, i.e. operators of the form

$$\begin{eqnarray}&&{X}_{R}:= \displaystyle \prod _{i\in R}{X}_{i},\qquad {Z}_{R}:= \displaystyle \prod _{i\in R}{Z}_{i},\end{eqnarray} \tag{ A1 }$$

where X_i, Z_i are the Pauli X, Z, operators on the ith qubit and R is a region, regarded here as set of vertices/qubits. Moreover, (i) a region R is free if and only if X_R and Z_R anticommute, and (ii) given two different regions R and ${R}^{\prime }$, X_R and ${Z}_{{R}^{\prime }}$ anticommute if and only if they share an odd number of odd borders. From this result it follows that to obtain a representative group ${ \mathcal L }$ of bare logical operators

$$\begin{eqnarray}&&{ \mathcal L }\subseteq { \mathcal Z }({ \mathcal G }),\qquad { \mathcal L }\simeq { \mathcal Z }({ \mathcal G })/{ \mathcal S },\end{eqnarray} \tag{ A2 }$$

it suffices to choose a minimal generating set for ${ \mathcal L }$ among X and Z region operators. It follows also that for frozen regions R the operators X_R and Z_R are stabilizer elements. In particular, if R is a frozen rgy-region with y-corners X_R can be obtained as a product of plaquette operators X_p as follows (and similarly for Z operators)

$$\begin{eqnarray}&&{X}_{R}=\displaystyle \prod _{{\rm{p}}\in {\text{}}{rg}-\mathrm{plaquettes}\ {in}\ {\text{}}R}{X}_{p}.\end{eqnarray} \tag{ A3 }$$

Indeed, every vertex/qubit belongs to exactly one rg-plaquette of $\bar{{\rm{\Lambda }}}$, and thus either (i) it belongs to exactly one rg-plaquette of Λ or (ii) it is part of an rg-border. The second options is never true for a frozen rgy-region with y-corners: it only shares vertices with ry-, gy- and by-borders. Moreover, R only borders with rby- and gby-regions, which cannot contain rg-plaquettes: if a vertex belongs to R, it belongs to a unique rg-plaquette contained in R.

When all the regions are free region operators cannot contribute any stabilizer generators: a product of X and Z region operators can only belong to the stabilizer if it is trivial. When all the regions are frozen, on the other hand, all region operators belong to the stabilizer. Region operators are, however, not independent. In a colex where all corners are y-corners the following identity holds (and similarly for Z operators)

$$\begin{eqnarray}&&\displaystyle \prod _{c\in {rgb}-\mathrm{cells}}{X}_{{\rm{c}}}\displaystyle \prod _{c\in {rgy}-\mathrm{cells}}{X}_{{\rm{c}}}=\displaystyle \prod _{R\in {rgy}-\mathrm{regions}}{X}_{{\rm{c}}},\end{eqnarray} \tag{ A4 }$$

where X_c are bit-flip cell operators and X_p are bit-flip plaquette operators. This is because each vertex/qubit belongs (i) exactly to one rgb-cell and (ii) exactly to one rgy-cell, unless it belongs to a rgy-region. Ulternatively, this lack of independence of region operators is a trivial consequence of the flux picture of the main text and the expression (A3): a flux incoming at a certain rg-plaquette of a given rgy-region has to exit at another rg-plaquette of another (or the same) rgy-region.

In tetrahedral codes all the regions are free and thus the stabilizer ${ \mathcal S }$ is generated by cell operators alone. In inner codes all the regions are frozen and thus the stabilizer has as generators (i) cell operators and (ii) region operators, except those coming from the facets of the original tetrahedral colex (facet operators are redundant due to (A4)). The take home message is that for all the geometries considered in the main text there exist a set local generators of the stabilizer.

Gauge color codes with local stabilizer and gauge generators exhibit single-shot error correction [11]. In particular, this is true for the above geometries when (i) all the regions are free or (ii) all the regions are frozen. The quantum-local process for fault-tolerant error correction can be split in two analogous processes that correct separately bit-flip and phase-flip errors. Let ${{ \mathcal G }}_{Z}$, ${{ \mathcal S }}_{Z}$ denote the gauge and stabilizer subgroups generated by Z operators. Single-shot error correction of bit-flip errors amounts to

• (1)  
  measure Z plaquette operators (generators of ${{ \mathcal G }}_{Z}$),
• (2)  
  process the measurements (classically) to obtain a syndrome σ for ${{ \mathcal S }}_{Z}$ (a subgroup of ${{ \mathcal G }}_{Z}$),
• (3)  
  choose a bit-flip operator E with syndrome σ, and
• (4)  
  apply E.

In the gauge color code families considered in the main text both the stabilizer and gauge group have local generators. Single-shot error correction is both possible for tetrahedral codes (because all regions are free) and for inner codes (because all regions are frozen).