Dependencies

When \(h(G) \geq 1\), the space code distance satisfies \(d^* \geq d\):

The spacetime fault-distance equals the Phase 2 duration:

The spacetime fault-distance is positive:

Any syndrome-free full gauging fault of weight \({\lt} d\) is a gauging stabilizer.

For any syndrome-free fault and any vertex \(v\), \(\operatorname {gaussFaultCount}(v, F) = 0\) or \(\operatorname {gaussFaultCount}(v, F) = d\).

Any pure-time fault that is syndrome-free, flips the gauging sign, has weight exactly \(d\), and \(d\) is odd, has exactly one vertex \(v\) with \(\operatorname {gaussFaultCount}(v, F) = d\).

Any syndrome-free pure-time fault of weight \({\lt} d\) (when \(d\) is odd) is a gauging stabilizer.

When \(d\) is odd and \(V\) is nonempty,

where \(t_o - t_i\) is the Phase 2 duration.

Addition in the group algebra, given by pointwise XOR (since coefficients are in \(\mathbb {Z}/2\mathbb {Z}\)). For polynomials \(p, q\), \((p + q)(\gamma ) = p(\gamma ) + q(\gamma )\).

The check map for a BB code: given polynomials \(A, B\), it maps X check indices (left summand) to \(\operatorname {bbCheckX}(A, B, \alpha )\) and Z check indices (right summand) to \(\operatorname {bbCheckZ}(A, B, \beta )\).

The check index type for a BB code: X checks indexed by \(M\) (left summand) and Z checks indexed by \(M\) (right summand). Formally, \(\operatorname {BBCheckIndex}(\ell , m) = M \oplus M\).

The X-type check indexed by \(\alpha \in M\) for polynomials \(A, B\). Its X-support on L qubits is the support of \(\operatorname {shift}_\alpha A\), and on R qubits is the support of \(\operatorname {shift}_\alpha B\):

The Z-type check indexed by \(\beta \in M\) for polynomials \(A, B\). Its Z-support on L qubits is the support of \(\operatorname {shift}_\beta B^T\), and on R qubits is the support of \(\operatorname {shift}_\beta A^T\):

A BB code forms a valid stabilizer code under the CSS condition \(AB^T = BA^T\). Given polynomials \(A, B\) in the group algebra satisfying the CSS condition, the stabilizer code has:

• Qubit type: \(\operatorname {BBQubit}(\ell , m) = M \oplus M\),

• Check index: \(\operatorname {BBCheckIndex}(\ell , m) = M \oplus M\),

• Check map: \(\operatorname {bbCheck}(A, B)\),

• Commutation: guaranteed by \(\operatorname {bbChecks\_ commute}\).

Convolution (polynomial multiplication) in \(\mathbb {F}_2[x,y]/(x^\ell - 1, y^m - 1)\). For polynomials \(p, q\):

where subtraction is taken in \(\mathbb {Z}_\ell \times \mathbb {Z}_m\). This corresponds to matrix multiplication of the associated circulant-like matrices.

The CSS condition for a BB code states that \(A * B^T = B * A^T\) as convolutions in the group algebra. This is the necessary and sufficient condition for all X and Z checks to commute, ensuring the parity check matrices satisfy \(H_X \cdot H_Z^T = 0\).

The group algebra \(\mathbb {F}_2[x,y]/(x^\ell - 1, y^m - 1)\). An element is a function \(M \to \mathbb {Z}/2\mathbb {Z}\), where the value at \((a,b)\) is the coefficient of \(x^a y^b\).

The monomial group \(M = \mathbb {Z}_\ell \times \mathbb {Z}_m\) represents monomials \(x^a y^b\) with \(a \in \{ 0, \ldots , \ell -1\} \) and \(b \in \{ 0, \ldots , m-1\} \). We use the additive group structure of \(\mathbb {Z}_\ell \times \mathbb {Z}_m\) (addition corresponds to monomial multiplication).

The monomial \(x^a y^b\) as an element of the group algebra: the indicator function of the single element \((a, b)\). That is, \(\operatorname {bbMonomial}(a, b)(\gamma ) = 1\) if \(\gamma = (a, b)\) and \(0\) otherwise.

The unit polynomial \(1 = x^0 y^0\) in the group algebra, defined as \(\operatorname {bbMonomial}(0, 0)\).

The qubit type for a BB code: Left (L) qubits and Right (R) qubits, each indexed by the monomial group \(M = \mathbb {Z}_\ell \times \mathbb {Z}_m\). Formally, \(\operatorname {BBQubit}(\ell , m) = M \oplus M\).

Left-shift a polynomial by monomial \(\alpha \): \((\operatorname {shift}_\alpha \, p)(\gamma ) = p(\gamma - \alpha )\). This corresponds to multiplication by \(x^a y^b\) in the group algebra.

The support of a polynomial \(p\): the set of monomials with nonzero coefficient, \(\operatorname {supp}(p) = \{ \alpha \in M \mid p(\alpha ) \neq 0 \} \).

The support of a polynomial as a finite set (decidable version), obtained by filtering the universe of \(M\) for monomials \(\alpha \) with \(p(\alpha ) \neq 0\).

The transpose operation on the group algebra: \(A^T(x,y) = A(x^{-1}, y^{-1})\). Since \(x^{-1} = x^{\ell -1}\) and \(y^{-1} = y^{m-1}\) in the quotient ring, this maps the coefficient of \(x^a y^b\) to \(x^{-a} y^{-b}\). Formally, \(\operatorname {bbTranspose}(p)(\alpha ) = p(-\alpha )\).

The zero polynomial in the group algebra, mapping every monomial to \(0\).

Left qubit labeled by \(\gamma \in M\), defined as \(\operatorname {Sum.inl}(\gamma )\) in the qubit type \(M \oplus M\).

The X-type Pauli operator \(X(p, q)\) on a BB code. It acts with \(X\) on L qubit \(\gamma \) iff \(p(\gamma ) = 1\), and on R qubit \(\delta \) iff \(q(\delta ) = 1\). This is a pure X-type operator (\(z\)-vector \(= 0\)). Formally: \(\operatorname {xVec} = \operatorname {Sum.elim}(p, q)\) and \(\operatorname {zVec} = 0\).

The Z-type Pauli operator \(Z(p, q)\) on a BB code. It acts with \(Z\) on L qubit \(\gamma \) iff \(p(\gamma ) = 1\), and on R qubit \(\delta \) iff \(q(\delta ) = 1\). This is a pure Z-type operator (\(x\)-vector \(= 0\)). Formally: \(\operatorname {xVec} = 0\) and \(\operatorname {zVec} = \operatorname {Sum.elim}(p, q)\).

Right qubit labeled by \(\delta \in M\), defined as \(\operatorname {Sum.inr}(\delta )\) in the qubit type \(M \oplus M\).

X check labeled by \(\alpha \in M\), defined as \(\operatorname {Sum.inl}(\alpha )\) in the check index type \(M \oplus M\).

The \(x\)-shift operator: the monomial \(x = x^1 y^0\) in the monomial group, represented as \((1, 0) \in \mathbb {Z}_\ell \times \mathbb {Z}_m\). Shifting by this monomial maps the coefficient at \((a, b)\) to \((a-1, b)\).

The \(y\)-shift operator: the monomial \(y = x^0 y^1\) in the monomial group, represented as \((0, 1) \in \mathbb {Z}_\ell \times \mathbb {Z}_m\). Shifting by this monomial maps the coefficient at \((a, b)\) to \((a, b-1)\).

Z check labeled by \(\beta \in M\), defined as \(\operatorname {Sum.inr}(\beta )\) in the check index type \(M \oplus M\).

The Cheeger constant \(h(G)\) of a finite simple graph \(G\) is defined as

The set of Cheeger-valid subsets of a finite vertex set \(V\) is the collection of all nonempty subsets \(S \subseteq V\) satisfying \(2|S| \le |V|\):

Given a qubit space \(W\), a control qubit \(c \in W\), a target qubit \(t \in W\) with \(c \neq t\), and a Pauli operator \(P \in \operatorname {PauliOp}(W)\), the CX conjugation \(\mathrm{CX}_{c \to t}(P)\) is the Pauli operator defined by:

Given a graph \(G\) on vertices \(V\) and a Pauli operator \(P \in \operatorname {PauliOp}(\operatorname {ExtQubit}(G))\), the entangling circuit action is the Pauli operator defined by:

where \([\! [v \in e]\! ]\) denotes the indicator for vertex \(v\) being an endpoint of edge \(e\), and \(\operatorname {inc}(v)\) is the set of edges incident to \(v\).

The cycle rank property for a graph \(G = (V, E)\) with a cycle collection \(C\) is the assertion that

This holds when \(C\) is a complete cycle basis for a connected graph \(G\), and is equivalent to the statement that the cycle rank (first Betti number) satisfies \(|C| = |E| - |V| + 1\).

The core incidence on subtypes: a vertex \(q \in V_L\) is incident to a check \(i \in E_L\) if and only if \((C.\operatorname {check}(i)).\operatorname {zVec}(q) \neq 0\).

An \(X\)-type logical operator \(L\) is irreducible if it cannot be written as a product \(L = P \cdot R\) of two pure \(X\)-type centralizer elements where both \(P\) and \(R\) have weight strictly less than \(\operatorname {wt}(L)\) and neither is the identity. Formally, \(L\) is an \(X\)-type logical and for all pure-\(X\) centralizer elements \(P, R\) with \(P \cdot R = L\), we have \(\operatorname {wt}(P) \ge \operatorname {wt}(L)\) or \(\operatorname {wt}(R) \ge \operatorname {wt}(L)\) or \(P = \mathbf{1}\) or \(R = \mathbf{1}\).

A Pauli operator \(L\) is an \(X\)-type logical operator for a stabilizer code \(C\) if \(L\) is pure \(X\)-type (i.e., \(L.\operatorname {zVec} = 0\)) and \(L\) is a logical operator of \(C\) (in the centralizer, not a stabilizer, and not the identity).

A check index \(i\) of a stabilizer code \(C\) is a \(Z\)-type check if the corresponding check operator has no \(X\)-support, i.e., the \(X\)-vector of \(C.\operatorname {check}(i)\) is zero.

The joint incidence relation combines two individual incidence relations with bridge edges. Given two systems \((Q_1, E_1, \operatorname {incident}_1)\) and \((Q_2, E_2, \operatorname {incident}_2)\) with bridge edges \(B\) connecting specified pairs, the joint incidence on vertices \(Q_1 \oplus Q_2\) and edges \(E_1 \oplus E_2 \oplus B\) is:

• \((\operatorname {inl}(q_1), \operatorname {inl}(e_1))\): \(\operatorname {incident}_1(q_1, e_1)\),

• \((\operatorname {inr}(q_2), \operatorname {inr}(\operatorname {inl}(e_2)))\): \(\operatorname {incident}_2(q_2, e_2)\),

• \((\operatorname {inl}(q_1), \operatorname {inr}(\operatorname {inr}(b)))\): \(q_1 = \operatorname {bridgeQ1}(b)\),

• \((\operatorname {inr}(q_2), \operatorname {inr}(\operatorname {inr}(b)))\): \(q_2 = \operatorname {bridgeQ2}(b)\),

• otherwise: \(\bot \).

The layered incidence relation for the Cohen et al. construction with \(d\) layers. The vertex set is \(Q \times \operatorname {Fin}(d)\) and edges are either inter-layer or intra-layer. A vertex \((q, \ell )\) is incident to:

• An inter-layer edge \((q', k)\): if \(q = q'\) and \(\ell \in \{ k, k+1\} \) (path graph connection between consecutive layers).

• An intra-layer edge \((i, \ell ')\): if \(\ell = \ell '\) and \(q\) is incident to check \(i\) in the restricted hypergraph.

Given a function \(g : V_L \to \mathbb {Z}_2\), the lift \(\operatorname {liftVL}(g) : Q \to \mathbb {Z}_2\) extends \(g\) by zero outside \(V_L\):

Given a Pauli operator \(L\) on qubits \(Q\), the logical support is defined as the \(X\)-support of \(L\):

The path graph on \(R\) vertices is the simple graph on \(\operatorname {Fin}(R)\) with adjacency given by \(\operatorname {pathGraphAdj}\), using the symmetry and irreflexivity proved above.

The path graph adjacency on \(R\) vertices: \(a\) and \(b\) in \(\operatorname {Fin}(R)\) are adjacent if \(a + 1 = b\) or \(b + 1 = a\).

The relevant \(Z\)-checks of a stabilizer code \(C\) with respect to a logical operator \(L\) are the \(Z\)-type check indices \(i\) whose \(Z\)-support has nonempty intersection with \(\operatorname {logicalSupport}(L)\):

The restricted boundary map \(\partial : \mathbb {Z}_2^{E_L} \to \mathbb {Z}_2^{V_L}\) is the hypergraph boundary map for the restricted incidence relation.

The restricted coboundary map \(\delta : \mathbb {Z}_2^{V_L} \to \mathbb {Z}_2^{E_L}\) is the hypergraph coboundary map (transpose of \(\partial \)) for the restricted incidence relation.

The restricted incidence relation for the hypergraph on \(\operatorname {logicalSupport}(L)\): a qubit \(q\) is incident to check index \(i\) if and only if \(q \in \operatorname {logicalSupport}(L)\), the \(Z\)-vector of \(C.\operatorname {check}(i)\) is nonzero at \(q\), and \(i\) is a \(Z\)-type check.

The global edge-cycle degree is the total number of generating cycles containing edge \(e\) across all layers:

The edge cycle degree in layer \(i\) counts how many original cycles assigned to layer \(i\) contain a given edge \(e\):

This is the per-layer edge participation count; the purpose of distributing cycles across layers is to make this quantitysmall.

The embedding of an original vertex \(v \in V\) into the sparsified vertex type is

An inter-layer edge between sparsified vertices \(p\) and \(q\) is defined by

i.e., they represent the same original vertex in consecutive layers.

An intra-layer edge between sparsified vertices \(p\) and \(q\) is defined by

i.e., \(p\) and \(q\) are in the same layer and the corresponding original vertices are adjacent in \(G\). The original graph edges are replicated in every layer.

A triangulation edge between sparsified vertices \(p\) and \(q\) exists when there is a cycle \(c\) such that:

1. The cycle \(c\) is assigned to a non-original layer: \(\operatorname {cycleAssignment}(c) \neq \operatorname {originalLayer}\).

2. Both \(p\) and \(q\) are in the layer assigned to \(c\): \(p_2 = q_2 = \operatorname {cycleAssignment}(c)\).

3. The pair \((p_1, q_1)\) or \((q_1, p_1)\) is a zigzag diagonal of \(c\)’s vertex list.

The per-layer cycle-degree bound states that for every edge \(e\) and every layer \(i\), the number of cycles assigned to layer \(i\) containing edge \(e\) is at most \(\mathit{bound}\):

The set of vertices in layer \(i\) is defined as

The minimum number of layers \(R_G^c\) for cycle-sparsification with per-layer cycle-degree bound \(\mathit{bound}\) is the smallest \(R\) such that there exists a cycle assignment \(f : C \to \operatorname {Fin}(R+1)\) achieving \(\operatorname {LayerCycleDegreeBound}(\mathit{cycles}, f, \mathit{bound})\). Formally, it is defined using \(\operatorname {Nat.find}\) applied to the existence hypothesis.

The original layer is layer \(0\), i.e., \(\operatorname {originalLayer} = \langle 0, \ldots \rangle : \operatorname {Fin}(R+1)\).

The complete data for a cycle-sparsified graph construction is a structure consisting of:

• \(\operatorname {numLayers} : \mathbb {N}\) — the number of additional layers \(R\).

• \(\operatorname {cycleAssignment} : C \to \operatorname {Fin}(R+1)\) — assigns each cycle to a layer.

• \(\operatorname {cycleVerts} : C \to \operatorname {List}(V)\) — the vertex list of each cycle.

• \(\operatorname {cycleBound} : \mathbb {N}\) — the per-layer cycle-degree bound.

• \(\operatorname {bound\_ holds}\) — proof that \(\operatorname {LayerCycleDegreeBound}(\mathit{cycles}, \operatorname {cycleAssignment}, \operatorname {cycleBound})\) holds.

Given sparsification data, the associated sparsified graph is

The adjacency relation of the sparsified graph combines all three edge types:

The cycle-sparsified graph \(\overline{\overline{G}}\) is defined as a \(\operatorname {SimpleGraph}\) on \(\operatorname {SparsifiedVertex}(V, R)\) with adjacency given by \(\operatorname {sparsifiedAdj}\), symmetry given by \(\operatorname {sparsifiedAdj\_ symm}\), and the loopless property given by \(\operatorname {sparsifiedAdj\_ irrefl}\).

The vertex type of the sparsified graph is \(V \times \operatorname {Fin}(R+1)\), where a pair \((v, i)\) represents vertex \(v\) in layer \(i\). Layer \(0\) is the original graph layer.

Given a list of cycle vertices \([v_1, v_2, \ldots , v_m]\), the zigzag diagonals are the cellulation diagonal pairs produced by the zigzag pattern:

For \(m {\lt} 4\), no diagonals are needed (the polygon is a triangle or simpler). For \(m = 4\) (square), one diagonal \((v_1, v_3)\). For \(m = 5\) (pentagon), two diagonals: \((v_1, v_4)\) and \((v_4, v_2)\).

Formally, if \(|\mathit{vs}| \ge 4\), define \(\mathit{arr}(i) = \mathit{vs}[i]\) and return \(\operatorname {zigzagGo}(\mathit{arr}, 0, |\mathit{vs}|-1, \ldots , \operatorname {true}, |\mathit{vs}|)\); otherwise return the empty list.

The auxiliary recursive function \(\operatorname {zigzagGo}\) takes a vertex array \(\mathit{vs} : \operatorname {Fin}(n) \to V\), left and right indices, a Boolean alternation flag \(\mathit{fromLeft}\), and a fuel parameter. It produces zigzag diagonal pairs by alternating between:

• If \(\mathit{fromLeft}\) is true: emit \((\mathit{vs}[\mathit{left}],\; \mathit{vs}[\mathit{right}-1])\) and recurse with \(\mathit{right}' = \mathit{right} - 1\) and flag false.

• If \(\mathit{fromLeft}\) is false: emit \((\mathit{vs}[\mathit{right}],\; \mathit{vs}[\mathit{left}+1])\) and recurse with \(\mathit{left}' = \mathit{left} + 1\) and flag true.

The recursion terminates when \(\mathit{right} \le \mathit{left} + 1\) or fuel is exhausted.

The BFS ball of radius \(r\) around vertex \(v\) in a graph \(G\) is

Given a collection of cycles \(\{ \gamma _c\} _{c \in C}\) over edges \(\alpha \), the maximum edge-cycle degree is

where \(d_e = |\{ c \in C : e \in \gamma _c\} |\) is the edge-cycle degree of \(e\).

The full set of checks for the deformed code is the function

defined by:

The check index type for the deformed code is the inductive type \(\operatorname {CheckIndex}(V, C, J)\) with three constructors:

• \(\operatorname {gaussLaw}(v)\) for \(v \in V\), indexing the Gauss’s law checks,

• \(\operatorname {flux}(p)\) for \(p \in C\), indexing the flux checks,

• \(\operatorname {deformed}(j)\) for \(j \in J\), indexing the deformed original checks.

This type is equivalent to the sum type \(V \oplus C \oplus J\).

Given a graph \(G = (V, E)\), an original check \(s \in \mathcal{P}_V\) (a Pauli operator on \(V\)), and an edge-path \(\gamma : E(G) \to \mathbb {Z}_2\) satisfying the boundary condition, the deformed check is the deformed operator extension of \(s\) by \(\gamma \):

The generating checks for the deformed code on the extended qubit system \(V \oplus E(G)\) is the main definition from Definition 4 of the paper. It is the function

defined as \(\operatorname {allChecks}(G, \mathrm{cycles}, \mathrm{checks}, \mathrm{data})\), mapping:

The deformed code data consists of:

• For each original check index \(j \in J\), an edge-path \(\gamma _j : E(G) \to \mathbb {Z}_2\).

• For each \(j \in J\), a proof that the boundary condition holds: \(\partial \gamma _j = S_Z(s_j)|_V\).

The deformed original checks \(\tilde{s}_j\) for each \(j \in J\) are defined using the edge-paths from the deformed code data:

where \(\gamma _j\) is the edge-path provided by the deformed code data.

The flux checks on the extended qubit system \(V \oplus E(G)\) are defined by

for each cycle \(p \in C\).

The Gauss’s law checks on the extended qubit system \(V \oplus E(G)\) are defined by

for each vertex \(v \in V\).

Given edge-paths \(\gamma _j : E(G) \to \mathbb {Z}_2\) for each \(j \in J\) and proofs that the boundary condition \(\partial \gamma _j = S_Z(s_j)|_V\) holds for each \(j\), construct the deformed code data.

When all original checks \(s_j\) have no \(Z\)-support on \(V\), the deformed code data can be constructed by setting all edge-paths to zero: \(\gamma _j = 0\) for all \(j \in J\). The boundary condition is satisfied because the zero edge-path has zero boundary, which equals the (empty) \(Z\)-support restriction when there is no \(Z\)-support.

The deformed code forms a valid stabilizer code on the extended qubit system \(V \oplus E(G)\). The check index type is \(\operatorname {CheckIndex}(V, C, J) = V \oplus C \oplus J\), and the check function is \(\operatorname {deformedCodeChecks}\). The pairwise commutation of all checks is established by allChecks_commute.

Formally, given a graph \(G\), cycles, original checks, deformed code data \(\mathrm{data}\), the cycle evenness hypothesis, and the hypothesis that original checks pairwise commute, we define:

with index type \(I = \operatorname {CheckIndex}(V, C, J)\) and check map \(\operatorname {deformedCodeChecks}(G, \mathrm{cycles}, \mathrm{checks}, \mathrm{data})\).

A Phase 2 measurement label for vertex set \(V\), cycle set \(C\), check set \(J\), and code distance \(d\) is one of:

1. \(\mathtt{gaussLaw}(v, r)\): Gauss’s law measurement at vertex \(v \in V\) in round \(r \in \operatorname {Fin}(d)\).

2. \(\mathtt{flux}(p, r)\): Flux measurement for cycle \(p \in C\) in round \(r \in \operatorname {Fin}(d)\).

3. \(\mathtt{deformed}(j, r)\): Deformed original check \(j \in J\) in round \(r \in \operatorname {Fin}(d)\).

The boundary condition for a Pauli operator \(P\) on \(V\) and an edge-path \(\gamma \in (\mathbb {Z}/2\mathbb {Z})^{E}\) asserts that

where \(\partial \) denotes the boundary map of the graph \(G\).

A Pauli operator \(P\) on \(V\) commutes with the logical operator \(L = \prod _{v \in V} X_v\) if the sum of its Z-support on vertices vanishes in \(\mathbb {Z}/2\mathbb {Z}\):

Equivalently, \(P\) has an even number of vertices with \(Z\)-action.

The deformed operator \(\widetilde{P} = P \cdot \prod _{e \in \gamma } Z_e\) on the extended qubit system \(V \oplus E\) is the main construction from Definition 3. Given a Pauli operator \(P\) on \(V\) and an edge-path \(\gamma \) satisfying the boundary condition \(\partial \gamma = S_Z(P)|_V\), the deformed operator is defined as

On vertex qubits it acts as \(P\), and on edge qubits it acts as \(Z_e\) if \(\gamma (e) = 1\) and as the identity otherwise. It commutes with all Gauss’s law operators \(A_v\).

The deformed operator \(\widetilde{P}\) on the extended qubit system \(V \oplus E\) is defined as follows. Given a Pauli operator \(P\) on \(V\) and an edge-path \(\gamma \in (\mathbb {Z}/2\mathbb {Z})^E\):

• On vertex qubits (\(v \in V\)): \(\widetilde{P}.\operatorname {xVec}(v) = P.\operatorname {xVec}(v)\) and \(\widetilde{P}.\operatorname {zVec}(v) = P.\operatorname {zVec}(v)\).

• On edge qubits (\(e \in E\)): \(\widetilde{P}.\operatorname {xVec}(e) = 0\) and \(\widetilde{P}.\operatorname {zVec}(e) = \gamma (e)\).

That is, \(\widetilde{P}\) acts as \(P\) on vertex qubits and as \(Z_e\) (if \(\gamma (e)=1\)) or identity (if \(\gamma (e)=0\)) on edge qubits.

A Pauli operator \(P\) on \(V\) has no Z-support on \(V\) if its Z-support on vertices is the zero vector:

The Z-support on vertices of a Pauli operator \(P\) on \(V\) is the binary vector \(\operatorname {zSupportOnVertices}(P) \in (\mathbb {Z}/2\mathbb {Z})^V\) defined by

This is the characteristic function of \(S_Z(P) \cap V\).

A structure bundling all three desiderata for graph \(G\) with parameters \(D\) and \(W\):

1. short_paths: \(G\) satisfies short paths for deformation with parameter \(D\).

2. expansion: \(G\) has sufficient expansion (\(h(G) \geq 1\)).

3. low_weight_cycles: The cycle basis of \(G\) has low weight with parameter \(W\).

A simple graph \(G\) has constant degree with parameter \(\Delta \) if for every vertex \(v\), \(\deg (v) \leq \Delta \).

The deformed code is LDPC with weight bound \(w\) and check bound \(c\) if the deformed stabilizer code satisfies the \(\operatorname {IsQLDPC}\) predicate with parameters \(w\) and \(c\).

Let \(G\) be a simple graph, let \(\{ \text{cycle}_c\} _{c \in C}\) be a family of subsets of edges, and let \(W \in \mathbb {N}\). The cycle basis is low-weight with parameter \(W\) if for every \(c \in C\), the number of edges in \(\text{cycle}_c\) is at most \(W\).

Let \(G\) be a simple graph on vertices \(V\), let \(\{ s_j\} _{j \in J}\) be a family of Pauli operators, and let \(D \in \mathbb {N}\). We say \(G\) satisfies short paths for deformation with parameter \(D\) if for every check \(s_j\) and every pair of vertices \(u, v\) in the \(Z\)-support of \(s_j\), the graph distance satisfies \(\operatorname {dist}_G(u,v) \leq D\).

A simple graph \(G\) has sufficient expansion if \(1 \leq h(G)\), where \(h(G)\) is the Cheeger constant of \(G\).

A detector is a structure \((D, f, c)\) where:

• \(D \subseteq M\) is a finite set of measurement labels (a \(\operatorname {Finset} M\)),

• \(f : M \to \mathbb {Z}/2\mathbb {Z}\) assigns to each measurement its ideal outcome (\(0 \leftrightarrow +1\), \(1 \leftrightarrow -1\)),

• \(c\) is a proof of the detector constraint: \(\sum _{m \in D} f(m) = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).

In the \(\{ +1, -1\} \) encoding, the constraint states that the product of ideal outcomes over the detector’s measurements equals \(+1\).

The weight of a detector \(D\) is the number of measurements it contains:

Given two detectors \(D_1, D_2\) with disjoint measurement sets and identical ideal outcomes, their disjoint union is the detector with:

• measurements \(= D_1.\mathrm{measurements} \cup D_2.\mathrm{measurements}\),

• ideal outcome \(= D_1.\mathrm{idealOutcome}\).

The detector constraint holds because the sum over the union splits into \(\sum _{D_1} + \sum _{D_2}\), both of which are \(0\).

The empty detector has no measurements (\(D.\mathrm{measurements} = \emptyset \)). The detector constraint is trivially satisfied since the empty sum is \(0\).

The flip parity of a detector \(D\) with respect to faults \(F\) is the sum in \(\mathbb {Z}/2\mathbb {Z}\) of the indicator of faulted measurements in \(D\):

A detector \(D\) is violated by a set of time-faults \(F\) if the observed parity equals \(1\):

Given a detector \(D\) and a set of time-faults \(F\), the observed parity is defined as

In \(\{ +1,-1\} \) encoding, \(0\) means the product of observed outcomes is \(+1\), and \(1\) means it is \(-1\).

A single-measurement detector for measurement \(m\) has measurements \(= \{ m\} \) and ideal outcome constantly \(0\). The constraint \(\sum _{m' \in \{ m\} } 0 = 0\) holds trivially. This detector fires when measurement \(m\) is faulted.

The syndrome of a set of time-faults \(F\) with respect to a family of detectors \((D_i)_{i \in I}\) is the set of detector indices whose detectors are violated:

The 6 distinct expansion edges (as ordered pairs in \(\mathbb {Z}_{12} \times \mathbb {Z}_{12}\)):

The edge \((x^2, x^6 y^3)\) has multiplicity 2 in the paper’s construction (yielding 7 expansion edges counting multiplicity).

Two monomials \(\gamma , \delta \) are adjacent in the gauging graph if \(\gamma \neq \delta \) and either they form a matching edge or an expansion edge.

The gauging graph \(G\) for measuring \(\bar{X}_\alpha \) in the Double Gross code is the simple graph on \(\mathbb {Z}_{12} \times \mathbb {Z}_{12}\) with adjacency \(\operatorname {dblGaugingAdj}\). Its symmetry is verified by native_decide, and irreflexivity follows from the \(\gamma \neq \delta \) condition.

The gauging vertices are the support of \(f\):

\(\operatorname {dblIsExpansionEdge}(\gamma , \delta )\) holds iff \((\gamma , \delta )\) or \((\delta , \gamma )\) appears in the expansion edge list.

A monomial difference \(d \in \mathbb {Z}_{12} \times \mathbb {Z}_{12}\) satisfies the matching condition if \(d = -B_i + B_j\) for some distinct terms \(B_i, B_j\) of \(B\), where the terms of \(B = y^3 + x^2 + x\) are \((0,3)\), \((2,0)\), and \((1,0)\).

Two monomials \(\gamma , \delta \) form a matching edge if both lie in \(\operatorname {supp}(f)\) and share a Z check, i.e., \(f(\gamma ) \neq 0\), \(f(\delta ) \neq 0\), and \(\operatorname {dblIsMatchingDiff}(\gamma - \delta )\).

For \(\alpha \in \operatorname {DGMonomial}\), the logical X operator is \(\bar{X}_\alpha = X(\alpha f, 0) = \operatorname {pauliXBB}(\operatorname {bbShift}(\alpha , f), 0)\).

The group algebra for the Double Gross code is \(\operatorname {DGAlgebra} := \operatorname {BBGroupAlgebra}(12, 12) = \mathbb {F}_2[x,y]/(x^{12} - 1, y^{12} - 1)\).

The monomial group for the Double Gross code is \(\operatorname {DGMonomial} := \operatorname {BBMonomial}(12, 12) = \mathbb {Z}_{12} \times \mathbb {Z}_{12}\).

The qubit type for the Double Gross code is \(\operatorname {DGQubit} := \operatorname {BBQubit}(12, 12)\).

The polynomial \(A = x^3 + y^7 + y^2\) in \(\mathbb {F}_2[x,y]/(x^{12} - 1, y^{12} - 1)\), defined as

The polynomial \(B = y^3 + x^2 + x\) in \(\mathbb {F}_2[x,y]/(x^{12} - 1, y^{12} - 1)\), defined as

The Double Gross code is a stabilizer code on qubits \(\operatorname {DGQubit}\), with check index set \(I = \operatorname {BBCheckIndex}(12, 12)\), check map \(\operatorname {bbCheck}(A, B)\), and commutation proof from the theorem above.

The logical operator polynomial \(f \in \mathbb {F}_2[x,y]/(x^{12} - 1, y^{12} - 1)\) is defined as:

An edge initialization label for edge set \(E\) is a structure recording a single edge \(e \in E\), representing initialization of the edge qubit in the \(|0\rangle \) state (treated as a measurement per Definition 7).

Given a Pauli operator \(P\) on extended qubits, a time \(t\), and a qubit \(q \in \operatorname {support}(P)\), we define the space fault

Given a Pauli operator \(P\) and a time \(t\), the finset of space-faults corresponding to \(P\) at time \(t\) is

Given a logical operator \(P\) of the deformed code, placing it as a collection of space-faults at time \(t_i\) (the start of Phase 2) produces a spacetime fault:

This has no time-faults (pure-space).

The fault-tolerant gauging measurement procedure for measuring a logical operator \(L\) in an \([\! [n,k,d]\! ]\) stabilizer code using a connected graph \(G = (V, E)\) with cycle set \(C\) and check set \(J\) is a structure consisting of:

1. \(d : \mathbb {N}\), the code distance (number of rounds per phase), with \(d \ge 1\).

2. A proof that the original stabilizer code checks pairwise commute: for all \(i, j \in J\), \(\operatorname {PauliCommute}(\mathit{checks}(i), \mathit{checks}(j))\).

3. A gauging input specifying the base vertex and connectivity data.

4. Deformed code data: edge-paths satisfying boundary conditions.

5. A cycle parity condition: for each cycle \(c \in C\) and vertex \(v \in V\), the number of edges in the cycle incident to \(v\) is even.

Given a fault-tolerant gauging procedure and a cycle \(p \in C\), the cycle edges of \(p\) is the finset of edges \(e \in G.\text{edgeSet}\) such that \(e \in \text{cycles}(p)\).

Given a fault-tolerant gauging procedure, a check index \(j \in J\), the last Phase 1 round \(r_{\text{last}}\) with \(r_{\text{last}} + 1 = d\), the first Phase 2 round \(r_{\text{first}} = 0\), and an outcome \(\sigma \in \mathbb {Z}/2\mathbb {Z}\), the deformed initialization detector \(\tilde{s}_j^{t_i}\) is the detector with:

• Measurements: \(\{ \texttt{phase1}(j, r_{\text{last}}),\; \texttt{phase2}(\texttt{deformed}(j, r_{\text{first}}))\} \cup \{ \texttt{edgeInit}(e) \mid e \in \gamma _j\} \).

• Ideal outcome: \(\sigma \) for the Phase 1 and Phase 2 deformed measurements, \(0\) for edge initializations.

• Constraint: \(\sigma + \sigma + \sum 0 = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).

Since \(\tilde{s}_j = s_j \cdot \prod _{e \in \gamma _j} Z_e\) and edge qubits are initialized in \(|0\rangle \) (so \(Z_e \to +1\)), the outcomes of \(s_j\) and \(\tilde{s}_j\) agree. The parameter \(\sigma \) encodes this unknown shared eigenvalue.

Given a fault-tolerant gauging procedure, a check index \(j \in J\), the last Phase 2 round \(r_{\text{last}}\) with \(r_{\text{last}} + 1 = d\), and the first Phase 3 round \(r_{\text{first}} = 0\), the deformed ungauging detector \(\tilde{s}_j^{t_o}\) is the detector with:

• Measurements: \(\{ \texttt{phase2}(\texttt{deformed}(j, r_{\text{last}})),\; \texttt{phase3}(\texttt{originalCheck}(j, r_{\text{first}}))\} \cup \{ \texttt{phase3}(\texttt{edgeZ}(e)) \mid e \in \gamma _j\} \).

• Ideal outcome: \(0\) for all measurements.

• Constraint: \(\tilde{\sigma }_j + \sum z_e + \sigma _j = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), since \(\tilde{s}_j = s_j \cdot \prod _{e \in \gamma _j} Z_e\) implies \(\tilde{\sigma }_j = \sigma _j + \sum z_e\).

The detector index type enumerates all detector generators in the spacetime code. Its constructors are:

• \(\texttt{phase1Repeated}(j, r, r', h_r)\): repeated measurement of original check \(s_j\) in Phase 1, at consecutive rounds \(r, r'\) with \(r + 1 = r'\).

• \(\texttt{phase2GaussRepeated}(v, r, r', h_r)\): repeated measurement of Gauss check \(A_v\) in Phase 2.

• \(\texttt{phase2FluxRepeated}(p, r, r', h_r)\): repeated measurement of flux check \(B_p\) in Phase 2.

• \(\texttt{phase2DeformedRepeated}(j, r, r', h_r)\): repeated measurement of deformed check \(\tilde{s}_j\) in Phase 2.

• \(\texttt{phase3Repeated}(j, r, r', h_r)\): repeated measurement of original check \(s_j\) in Phase 3.

• \(\texttt{fluxInit}(p)\): boundary detector \(B_p^{t_i}\) at gauging step.

• \(\texttt{deformedInit}(j)\): boundary detector \(\tilde{s}_j^{t_i}\) at gauging step.

• \(\texttt{fluxUngauge}(p)\): boundary detector \(B_p^{t_o}\) at ungauging step.

• \(\texttt{deformedUngauge}(j)\): boundary detector \(\tilde{s}_j^{t_o}\) at ungauging step.

No standalone edge-initialization detectors are needed: edge initialization and readout events are covered by the composite boundary detectors.

The map from detector indices to actual detectors. Repeated measurement detectors take outcome \(0\) as a canonical choice (the constraint proof works for any outcome). The boundary detectors use the first/last rounds \(r = 0\) and \(r = d - 1\).

The edge initialization detector for edge \(e\) compares the initialization event \(\mathtt{edgeInit}(\langle e \rangle )\) with the Phase 3 measurement \(\mathtt{phase3}(\mathtt{edgeZ}(e))\), with ideal outcome \(0\).

Given a fault-tolerant gauging procedure and a check index \(j \in J\), the edge-path edges of \(j\) is the finset of edges \(e \in G.\text{edgeSet}\) such that \(\text{edgePath}(j, e) \neq 0\) in \(\mathbb {Z}/2\mathbb {Z}\).

Given a fault-tolerant gauging procedure, a cycle \(p \in C\), and the first round \(r_{\text{first}}\) with \(r_{\text{first}} = 0\), the flux initialization detector \(B_p^{t_i}\) is the detector with:

• Measurements: \(\{ \texttt{edgeInit}(e) \mid e \in \text{cycles}(p)\} \cup \{ \texttt{phase2}(\texttt{flux}(p, r_{\text{first}}))\} \).

• Ideal outcome: \(0\) for all measurements.

• Constraint: \(\sum 0 = 0\).

Edge qubits initialized in \(|0\rangle \) are \(Z\)-eigenstates with eigenvalue \(+1\) (i.e., \(0\) in \(\mathbb {Z}/2\mathbb {Z}\)). Since \(B_p = \prod _{e \in p} Z_e\) is pure \(Z\)-type, \(B_p\) on these \(|0\rangle \) states gives outcome \(\sum 0 = 0\).

Given a fault-tolerant gauging procedure, a cycle \(p \in C\), and the last round \(r_{\text{last}}\) with \(r_{\text{last}} + 1 = d\), the flux ungauging detector \(B_p^{t_o}\) is the detector with:

• Measurements: \(\{ \texttt{phase2}(\texttt{flux}(p, r_{\text{last}}))\} \cup \{ \texttt{phase3}(\texttt{edgeZ}(e)) \mid e \in \text{cycles}(p)\} \).

• Ideal outcome: \(0\) for all measurements.

• Constraint: \(\beta _p + \sum z_e = 0\) in \(\mathbb {Z}/2\mathbb {Z}\), since \(B_p = \prod _{e \in p} Z_e\) means \(\beta _p = \sum z_e\).

The gauging measurement sign from Phase 2 Gauss outcomes is

For each detector index, the generator measurement set is the measurement set of the corresponding detector.

The Boolean predicate \(\mathtt{isPhase1}\) returns true if and only if the measurement label is of the form \(\mathtt{phase1}(\_ )\).

The Boolean predicate \(\mathtt{isPhase2}\) returns true if and only if the measurement label is of the form \(\mathtt{phase2}(\_ )\) or \(\mathtt{edgeInit}(\_ )\).

The Boolean predicate \(\mathtt{isPhase3}\) returns true if and only if the measurement label is of the form \(\mathtt{phase3}(\_ )\).

The function \(\mathtt{measurementPhase}\) assigns a phase to each measurement label:

• \(\mathtt{phase1}(\_ ) \mapsto \text{preDeformation}\),

• \(\mathtt{edgeInit}(\_ ) \mapsto \text{deformedCode}\),

• \(\mathtt{phase2}(\_ ) \mapsto \text{deformedCode}\),

• \(\mathtt{phase3}(\_ ) \mapsto \text{postDeformation}\).

The function \(\mathtt{measurementTime}\) assigns an integer time step to each measurement label:

• \(\mathtt{phase1}(\langle j, r \rangle ) \mapsto r\),

• \(\mathtt{edgeInit}(\_ ) \mapsto d\),

• \(\mathtt{phase2}(\mathtt{gaussLaw}\; v\; r) \mapsto d + r\); similarly for flux and deformed measurements,

• \(\mathtt{phase3}(\mathtt{edgeZ}\; e) \mapsto 2d\); \(\mathtt{phase3}(\mathtt{originalCheck}\; j\; r) \mapsto 2d + r\).

The boundary detector from Phase 1 to Phase 2 for check \(j\) compares the last Phase 1 round measurement \(\mathtt{phase1}(\langle j, r_{\text{last}} \rangle )\) with the first Phase 2 deformed check measurement \(\mathtt{phase2}(\mathtt{deformed}(j, r_{\text{first}}))\), where \(r_{\text{last}} + 1 = d\) and \(r_{\text{first}} = 0\), with ideal outcome \(0\).

For consecutive Phase 1 rounds \(r\) and \(r'\) (with \(r + 1 = r'\)), the repeated measurement detector for check \(j\) compares the outcomes of measuring check \(j\) in rounds \(r\) and \(r'\). It consists of the measurement set \(\{ \mathtt{phase1}(\langle j, r \rangle ), \mathtt{phase1}(\langle j, r' \rangle )\} \) with ideal outcome \(0\) for all measurements.

Given a fault-tolerant gauging procedure, a check index \(j \in J\), consecutive rounds \(r, r' \in \operatorname {Fin}(d)\) with \(r + 1 = r'\), and an outcome \(\sigma \in \mathbb {Z}/2\mathbb {Z}\), the Phase 1 repeated detector is the detector with:

• Measurements: \(\{ \texttt{phase1}(j, r),\; \texttt{phase1}(j, r')\} \).

• Ideal outcome: \(\sigma \) on both measurements, \(0\) otherwise.

• Constraint: \(\sigma + \sigma = 0\) in \(\mathbb {Z}/2\mathbb {Z}\) (by characteristic 2).

The outcome \(\sigma \) represents the unknown but equal eigenvalue of both measurements of the self-inverse check \(s_j\).

The boundary detector from Phase 2 to Phase 3 for check \(j\) compares the last Phase 2 deformed check measurement \(\mathtt{phase2}(\mathtt{deformed}(j, r_{\text{last}}))\) with the first Phase 3 original check measurement \(\mathtt{phase3}(\mathtt{originalCheck}(j, r_{\text{first}}))\), where \(r_{\text{last}} + 1 = d\) and \(r_{\text{first}} = 0\), with ideal outcome \(0\).

The Pauli operator measured for a Phase 2 measurement \(\mathit{dm}\) is:

• \(\mathtt{gaussLaw}(v, r) \mapsto \text{gaussLawChecks}(G, v)\),

• \(\mathtt{flux}(p, r) \mapsto \text{fluxChecks}(G, \mathit{cycles}, p)\),

• \(\mathtt{deformed}(j, r) \mapsto \text{deformedOriginalChecks}(G, \mathit{checks}, \mathit{deformedData}, j)\).

For consecutive Phase 2 rounds \(r\) and \(r'\), the repeated measurement detector for deformed check \(j\) compares the outcomes of \(\mathtt{deformed}(j, r)\) and \(\mathtt{deformed}(j, r')\) with ideal outcome \(0\).

For consecutive Phase 2 rounds \(r\) and \(r'\), the repeated measurement detector for flux at cycle \(p\) compares the outcomes of \(\mathtt{flux}(p, r)\) and \(\mathtt{flux}(p, r')\) with ideal outcome \(0\).

For consecutive Phase 2 rounds \(r\) and \(r'\), the repeated measurement detector for Gauss’s law at vertex \(v\) compares the outcomes of \(\mathtt{gaussLaw}(v, r)\) and \(\mathtt{gaussLaw}(v, r')\) with ideal outcome \(0\).

Phase 2 begins at time \(d\).

Given a fault-tolerant gauging procedure, a check index \(j \in J\), consecutive rounds \(r, r' \in \operatorname {Fin}(d)\) with \(r + 1 = r'\), and an outcome \(\sigma \in \mathbb {Z}/2\mathbb {Z}\), the Phase 3 repeated detector is the detector with:

• Measurements: \(\{ \texttt{phase3}(\texttt{originalCheck}(j, r)),\; \texttt{phase3}(\texttt{originalCheck}(j, r'))\} \).

• Ideal outcome: \(\sigma \) on both measurements, \(0\) otherwise.

• Constraint: \(\sigma + \sigma = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).

Phase 3 begins at time \(2d\).

The procedure ends at time \(3d\).

The dummy \(X\) product \(\prod _{d \in D} X_d\) acting on \(V \oplus D\) is the Pauli operator with

The extended logical operator \(L'\) on the extended vertex type \(V \oplus D\) is defined as

i.e., the Pauli operator with \(\mathrm{xVec}(q) = 1\) for all \(q \in V \oplus D\) and \(\mathrm{zVec} = 0\).

The lifted logical operator \(L_{\mathrm{lift}}\) on \(V \oplus D\) acts as \(X\) on all \(V\)-qubits and as the identity on \(D\)-qubits:

The original logical operator \(L\) on vertex set \(V\) is defined as

i.e., the Pauli operator with \(\mathrm{xVec}(v) = 1\) for all \(v \in V\) and \(\mathrm{zVec} = 0\).

Given an edge vector \(\delta : E(G) \to \mathbb {Z}/2\mathbb {Z}\), the pure-Z edge operator is defined as

i.e., the deformed operator extension of the identity operator \(\mathbf{1}\) with edge-path \(\delta \). This operator acts as the identity on all vertex qubits and applies \(Z_e\) on edge qubit \(e\) whenever \(\delta (e) = 1\).

The type of all measurement labels across the entire fault-tolerant gauging procedure is the inductive type with four constructors:

1. \(\mathtt{phase1}(m)\): A Phase 1 measurement \(m\).

2. \(\mathtt{edgeInit}(\mathit{init})\): An edge initialization event.

3. \(\mathtt{phase2}(m)\): A Phase 2 measurement \(m\).

4. \(\mathtt{phase3}(m)\): A Phase 3 measurement \(m\).

The byproduct correction at vertex \(v\), given a specific walk \(\gamma \) from \(v_0\) to \(v\), is defined as the walk parity:

Here \(c(v) = 1\) means “apply \(X_v\)” (corresponding to \(\prod _{e \in \gamma } \omega _e = -1\) in \(\pm 1\) notation).

The byproduct correction Pauli operator for a given walk assignment: for each vertex \(v\), apply \(X_v\) if and only if \(c(v) = 1\). Formally, this is the Pauli operator with

The edge \(Z\) operator measured at edge \(e\) in step 4 of the gauging procedure:

defined as \(\operatorname {pauliZ}(\operatorname {inr}(e))\).

The gauging measurement algorithm: given input data, measurement outcomes, and a choice of walks from \(v_0\) to each vertex, computes the classical output:

• \(\operatorname {sign} = \sum _{v \in V} \varepsilon _v\) (the sum of all Gauss outcomes in \(\mathbb {Z}/2\mathbb {Z}\)).

• \(\operatorname {correction}(v) = \operatorname {walkParity}(\gamma _v, \omega )\) (the parity of edge outcomes along the walk from \(v_0\) to \(v\)).

The input data for the gauging measurement procedure consists of:

• A connected graph \(G = (V, E)\) with \(V\) the support of the logical operator \(L = \prod _{v \in V} X_v\).

• A distinguished base vertex \(v_0 \in V\) for byproduct correction.

• A proof that \(G\) is connected.

The measurement outcomes from the gauging procedure. We use \(\mathbb {Z}/2\mathbb {Z}\) to represent \(\pm 1\) outcomes (\(0 \leftrightarrow +1\), \(1 \leftrightarrow -1\)):

• \(\varepsilon _v \in \mathbb {Z}/2\mathbb {Z}\): the outcome of measuring Gauss’s law operator \(A_v\) for each \(v \in V\).

• \(\omega _e \in \mathbb {Z}/2\mathbb {Z}\): the outcome of measuring \(Z_e\) for each \(e \in E\).

The classical output of the gauging measurement algorithm, consisting of:

• The measurement sign \(\sigma \in \mathbb {Z}/2\mathbb {Z}\): \(0 \leftrightarrow +1\) eigenvalue of \(L\), \(1 \leftrightarrow -1\) eigenvalue.

• The byproduct correction vector \(c : V \to \mathbb {Z}/2\mathbb {Z}\), where \(c(v) = 1\) means apply \(X_v\).

The Gauss’s law operator measured at vertex \(v\) in step 3 of the gauging procedure:

on the extended qubit system \(V \oplus E\). This is the abbreviation for \(\operatorname {gaussLawOp}(G, v)\).

The measurement sign \(\sigma = \sum _{v \in V} \varepsilon _v \in \mathbb {Z}/2\mathbb {Z}\), encoding the product of all Gauss’s law outcomes. This is the measurement result of the logical operator \(L = \prod _{v \in V} X_v\): \(\sigma = 0\) means the \(+1\) eigenvalue, \(\sigma = 1\) means \(-1\).

The proposition that \(\sigma = 1 \pmod{2}\), meaning the \(-1\) eigenvalue of \(L\) was measured.

The proposition that \(\sigma = 0 \pmod{2}\), meaning the \(+1\) eigenvalue of \(L\) was measured.

Given edge measurement outcomes \(\omega \) and a walk \(w\) in \(G\) from \(u\) to \(v\), the walk parity is the \(\mathbb {Z}/2\mathbb {Z}\)-sum of \(\omega (e)\) over all edges \(e\) traversed by the walk:

The \(\sigma \)-dependent projector pair on vertex qubits, representing the Pauli decomposition of \(\mathbf{1} + \sigma L\):

where the first component is the identity operator and the second has \(X\)-vector \(v \mapsto \sigma \) and \(Z\)-vector \(0\). When \(\sigma = 0\), both components are the identity; when \(\sigma = 1\), the second component is \(L|_V\).

The indicator function of a finset \(S \subseteq V\) as a binary vector:

Let \(G\) be a simple graph on vertex set \(V\) with edge set \(E(G)\). Given a binary vector \(c : V \to \mathbb {Z}/2\mathbb {Z}\), define the Pauli operator \(\operatorname {gaussSubsetProduct}(c)\) on the extended qubit system \(V \oplus E(G)\) by:

where \(\delta \) denotes the coboundary map. This represents the product \(\prod _{v \in \operatorname {supp}(c)} A_v\) of Gauss’s law operators, yielding \(X_V(c) \cdot X_E(\delta c)\) on the extended system.

The logical operator \(L\) restricted to vertex qubits only:

i.e., the Pauli operator with \(X\)-vector identically \(1\) and \(Z\)-vector identically \(0\).

A gauging procedure implements a projective measurement of \(L\) if the following conditions hold:

1. Sign determination: The measurement sign \(\sigma \) equals \(\sum _{v \in V} \varepsilon _v\), the sum of all Gauss outcomes.

2. Gauss product: \(\prod _{v \in V} A_v = L\).

3. Preimage structure: For any \(c'\) with \(\delta c' = \omega \), every \(c\) with \(\delta c = \omega \) satisfies \(c = c'\) or \(c = c' + \mathbf{1}\).

4. Two terms: \(\operatorname {gaussSubsetProduct}(c' + \mathbf{1}) = \operatorname {gaussSubsetProduct}(c') \cdot L\).

5. Signed outcome additivity: \(\varepsilon (c' + \mathbf{1}) = \varepsilon (c') + \sigma \).

6. Walk parity preimage: Under the closed-walk-zero-parity condition, \(\delta (\operatorname {walkParityVector}(\gamma , \omega )) = \omega \).

7. Correction pure \(X\): The byproduct correction operator has \(Z\)-vector \(0\).

8. Correction commutes with \(L|_V\): The correction is a pure \(X\)-type operator, hence commutes with \(L|_V\).

9. Correction self-inverse: Applying the correction twice gives the identity.

10. Walk independence: Under the closed-walk-zero-parity condition, the walk parity vector is independent of the choice of walks.

The signed outcome function \(\varepsilon (c)\) for a binary outcome vector \(\varepsilon : V \to \mathbb {Z}/2\mathbb {Z}\) and subset vector \(c : V \to \mathbb {Z}/2\mathbb {Z}\) is:

This encodes the product \(\prod _{v \in \operatorname {supp}(c)} \varepsilon _v\) of \(\pm 1\) outcomes as an additive quantity in \(\mathbb {Z}/2\mathbb {Z}\).

Given a base vertex \(v_0 \in V\), a family of walks \(\gamma _v : v_0 \leadsto v\) for each \(v \in V\), and an edge outcome vector \(\omega : E(G) \to \mathbb {Z}/2\mathbb {Z}\), the walk parity vector is:

This gives the byproduct correction vector from walk parities.

The three phases of the fault-tolerant gauging procedure form an inductive type with three constructors:

1. preDeformation: Phase 1, in which the original stabilizer checks are measured.

2. deformedCode: Phase 2, in which the deformed code checks (Gauss’s law, flux, and deformed original checks) are measured.

3. postDeformation: Phase 3, in which the edge qubits are ungauged and the original checks are resumed.

The type has decidable equality and is a finite type with exactly three elements.

The cycle incident count of a vertex \(v\) and a cycle \(p\) is the number of edges in \(p\) that are incident to \(v\):

For a valid cycle, this is always even (either \(0\) or \(2\)).

The extended qubit type for a graph \(G = (V,E)\) is the sum type

where \(\operatorname {Sum.inl}(v)\) represents a vertex qubit and \(\operatorname {Sum.inr}(e)\) represents an edge qubit.

The flux operator \(B_p\) on the extended system \(V \oplus E\) is the Pauli operator defined by:

That is, \(B_p = \prod _{e \in p} Z_e\): it acts with \(Z\) on all edge qubits in cycle \(p\).

The Gauss’s law operator \(A_v\) on the extended system \(V \oplus E\) is the Pauli operator defined by:

That is, \(A_v = X_v \prod _{e \ni v} X_e\): it acts with \(X\) on vertex qubit \(v\) and all incident edge qubits.

For a vertex \(v \in V\), the incident edges of \(v\) is the finset

The logical operator \(L = \prod _{v \in V} X_v\) on the extended system is the Pauli operator defined by:

That is, \(L\) acts with \(X\) on all vertex qubits and with the identity on all edge qubits.

The qudit boundary map \(\partial : \mathbb {Z}_p^E \to \mathbb {Z}_p^V\) generalizes the boundary map from \(\mathbb {Z}_2\) to \(\mathbb {Z}_p\). For \(\gamma \in \mathbb {Z}_p^E\), the value at vertex \(v\) is

This is a \(\mathbb {Z}_p\)-linear map, with linearity verified by distributing sums and scalar multiplication over the conditional summation.

The qudit coboundary map \(\delta : \mathbb {Z}_p^V \to \mathbb {Z}_p^E\) generalizes the coboundary map from \(\mathbb {Z}_2\) to \(\mathbb {Z}_p\). For \(f \in \mathbb {Z}_p^V\) and edge \(e = \{ a,b\} \), the value is

This is a \(\mathbb {Z}_p\)-linear map.

The qudit hypergraph boundary map \(\partial : \mathbb {Z}_p^E \to \mathbb {Z}_p^V\) generalizes both the graph case and the hypergraph case from \(\mathbb {Z}_2\) to \(\mathbb {Z}_p\). For \(\gamma \in \mathbb {Z}_p^E\),

where \(v \sim e\) means \(v\) is incident to hyperedge \(e\).

The qudit hypergraph coboundary map \(\delta : \mathbb {Z}_p^V \to \mathbb {Z}_p^E\) generalizes the hypergraph coboundary from \(\mathbb {Z}_2\) to \(\mathbb {Z}_p\). For \(f \in \mathbb {Z}_p^V\),

The qudit second boundary map \(\partial _2 : \mathbb {Z}_p^C \to \mathbb {Z}_p^E\) generalizes the second boundary map from \(\mathbb {Z}_2\) to \(\mathbb {Z}_p\). For \(\sigma \in \mathbb {Z}_p^C\), the value at edge \(e\) is

The qudit second coboundary map \(\delta _2 : \mathbb {Z}_p^E \to \mathbb {Z}_p^C\) generalizes the second coboundary map from \(\mathbb {Z}_2\) to \(\mathbb {Z}_p\). For \(\gamma \in \mathbb {Z}_p^E\), the value at cycle \(c\) is

The all-ones function \(\mathbf{1} : V \to \mathbb {Z}/2\mathbb {Z}\) is defined by \(\mathbf{1}(v) = 1\) for all \(v \in V\).

The boundary map \(\partial : \mathbb {Z}_2^E \to \mathbb {Z}_2^V\) is the \(\mathbb {Z}_2\)-linear map defined as follows. For \(\gamma \in \mathbb {Z}_2^E\) and a vertex \(v \in V\),

The coboundary map \(\delta : \mathbb {Z}_2^V \to \mathbb {Z}_2^E\) is the \(\mathbb {Z}_2\)-linear map defined as follows. For \(f \in \mathbb {Z}_2^V\) and an edge \(e = \{ a, b\} \in E\),

Let \(C\) be a finite type of “cycles” (or plaquettes), and let each \(c \in C\) be associated with a set of edges \(\operatorname {cycles}(c) \subseteq E\). The second boundary map \(\partial _2 : \mathbb {Z}_2^C \to \mathbb {Z}_2^E\) is the \(\mathbb {Z}_2\)-linear map defined by: for \(\sigma \in \mathbb {Z}_2^C\) and an edge \(e \in E\),

The second coboundary map \(\delta _2 : \mathbb {Z}_2^E \to \mathbb {Z}_2^C\) is the \(\mathbb {Z}_2\)-linear map defined by: for \(\gamma \in \mathbb {Z}_2^E\) and a cycle \(c \in C\),

The 4 expansion edges ensuring the deformed code has distance 12, given as pairs of monomials:

The adjacency relation on the gauging graph: \(\gamma \) and \(\delta \) are adjacent if \(\gamma \neq \delta \) and either \((\gamma , \delta )\) is a matching edge or an expansion edge.

The 7 independent cycles for the flux checks, given as lists of vertices. Each list \([v_1, v_2, \ldots , v_k]\) represents the cycle \(v_1 \to v_2 \to \cdots \to v_k \to v_1\):

1. \([(9,0),\, (7,3),\, (8,0)]\)

2. \([(9,0),\, (11,3),\, (7,3)]\)

3. \([(6,0),\, (7,0),\, (5,3)]\)

4. \([(6,0),\, (2,0),\, (5,3)]\)

5. \([(3,0),\, (2,0),\, (5,3)]\)

6. \([(6,0),\, (7,0),\, (8,0),\, (7,3)]\)

7. \([(1,0),\, (2,0),\, (5,3),\, (11,3)]\)

The gauging graph \(G\) for measuring \(\bar{X}_\alpha \) in the Gross code is the simple graph on \(\operatorname {GrossMonomial} = \mathbb {Z}_{12} \times \mathbb {Z}_6\) with adjacency given by \(\operatorname {gaugingAdj}\). The “active” vertices are \(\operatorname {supp}(f)\).

The gauging vertices are the support of \(f\): the set of monomials \(\gamma \in \mathbb {Z}_{12} \times \mathbb {Z}_6\) such that \(f(\gamma ) \neq 0\):

The polynomial \(A \in \mathbb {F}_2[x,y]/(x^{12}-1, y^6-1)\) is defined as

The group algebra for the Gross code is \(\operatorname {BBGroupAlgebra}(12, 6) = \mathbb {F}_2[x,y]/(x^{12}-1, y^6-1)\).

The polynomial \(B \in \mathbb {F}_2[x,y]/(x^{12}-1, y^6-1)\) is defined as

The Gross code is a stabilizer code with check index set \(\operatorname {BBCheckIndex}(12,6)\), check map \(\operatorname {bbCheck}(A, B)\), and the proof that all checks pairwise commute.

The logical operator polynomial \(f \in \mathbb {F}_2[x,y]/(x^{12}-1, y^6-1)\) is defined as

The logical operator polynomial \(g \in \mathbb {F}_2[x,y]/(x^{12}-1, y^6-1)\) is defined as

The logical operator polynomial \(h \in \mathbb {F}_2[x,y]/(x^{12}-1, y^6-1)\) is defined as

The monomial group for the Gross code is \(\operatorname {BBMonomial}(12, 6) = \mathbb {Z}_{12} \times \mathbb {Z}_6\).

The qubit type for the Gross code is \(\operatorname {BBQubit}(12, 6)\), consisting of left (\(L\)) and right (\(R\)) qubits indexed by elements of \(\mathbb {Z}_{12} \times \mathbb {Z}_6\).

A pair \((\gamma , \delta )\) is an expansion edge if it appears (in either order) in the list of 4 expansion edges.

A monomial difference \(d\) is a matching difference if \(d = -B_i + B_j\) for some distinct terms \(B_i, B_j\) of \(B = y^3 + x^2 + x\), where the terms of \(B\) are \((0,3)\), \((2,0)\), and \((1,0)\) in \(\mathbb {Z}_{12} \times \mathbb {Z}_6\), and \(d \neq 0\).

Two monomials \(\gamma \) and \(\delta \) form a matching edge if both are in \(\operatorname {supp}(f)\) (i.e., \(f(\gamma ) \neq 0\) and \(f(\delta ) \neq 0\)) and their difference \(\gamma - \delta \) is a matching difference. This corresponds to \(\gamma \) and \(\delta \) sharing a \(Z\) check.

For \(\alpha \in \mathbb {Z}_{12} \times \mathbb {Z}_6\), the logical X operator is

where \(\alpha \cdot f\) denotes the shift of \(f\) by \(\alpha \).

For \(\beta \in \mathbb {Z}_{12} \times \mathbb {Z}_6\), the logical X\('\) operator is

For \(\beta \in \mathbb {Z}_{12} \times \mathbb {Z}_6\), the logical Z operator is

where \(h^T\) and \(g^T\) denote the transposes (negation of exponents) of \(h\) and \(g\).

For \(\alpha \in \mathbb {Z}_{12} \times \mathbb {Z}_6\), the logical Z\('\) operator is

The hypergraph boundary map \(\partial : \mathbb {Z}_2^E \to \mathbb {Z}_2^V\) is the \(\mathbb {Z}_2\)-linear map defined by

for \(\gamma \in \mathbb {Z}_2^E\) and \(v \in V\). This generalizes the graph boundary map: for graphs, each edge is incident to exactly two vertices; for hypergraphs, a hyperedge can be incident to any nonempty set of vertices.

The hypergraph coboundary map \(\delta : \mathbb {Z}_2^V \to \mathbb {Z}_2^E\) is the transpose of \(\partial \). For \(f \in \mathbb {Z}_2^V\),

Given a hyperedge \(e \in E\), the set of vertices contained in \(e\) is

The hypergraph Gauss’s law operator \(A_v\) on the extended system \(V \oplus E\) is defined as the Pauli operator with

i.e., its \(X\)-vector is \((\operatorname {xVec})_q = \begin{cases} 1 & \text{if } q = \operatorname {inl}(v), \\ 1 & \text{if } q = \operatorname {inr}(e) \text{ and } \operatorname {incident}(v,e), \\ 0 & \text{otherwise,} \end{cases}\) and its \(Z\)-vector is identically zero.

The Gauss subset product for a vector \(c \in \mathbb {Z}_2^V\) is the product \(\prod _{v : c_v = 1} A_v\), defined as the Pauli operator on \(V \oplus E\) with

and \(\operatorname {zVec} = 0\). On vertex qubits the \(X\)-vector is \(c\); on edge qubits it equals the coboundary \(\delta c\).

Given a hypergraph incidence relation \(\operatorname {incident} : V \to E \to \operatorname {Prop}\) and a vertex \(v \in V\), the set of hyperedges incident to \(v\) is

A hypergraph is graph-like if every hyperedge has exactly \(2\) vertices:

Given an edge vector \(\gamma \in \mathbb {Z}_2^E\), the pure-\(Z\) hyperedge operator on \(V \oplus E\) acts as \(Z\) on hyperedge qubit \(e\) if and only if \(\gamma _e = 1\). Formally, \(\operatorname {xVec} = 0\) and

Given an edge vector \(\gamma \in \mathbb {Z}_2^E\), the corresponding \(X\)-type operator on vertex qubits \(V\) is

defined as the Pauli operator with \(\operatorname {xVec} = \partial \gamma \) and \(\operatorname {zVec} = 0\).

An initialization-measurement detector is formed from an initialization event \(m_{\mathrm{init}}\) and a later measurement \(m_{\mathrm{meas}}\) with \(m_{\mathrm{init}} \neq m_{\mathrm{meas}}\), both having the same ideal outcome \(o\). Per Definition 7, initializations are treated as measurements, so this forms a valid detector with measurements \(\{ m_{\mathrm{init}}, m_{\mathrm{meas}}\} \) and ideal outcome \(o\) on both, satisfying the constraint \(o + o = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).

Let \(\alpha \) be a type with decidable equality and let \(\{ \text{generators}_i\} _{i \in \iota }\) be a family of finsets over \(\alpha \). A finset \(S\) is \(\mathbb {Z}_2\)-generated by the generators if \(S\) can be obtained from \(\emptyset \) by iterated symmetric differences with generators. Formally, this is defined inductively:

• \(\emptyset \) is generated.

• If \(S\) is generated, then \(S \mathbin {\triangle } \text{generators}_i\) is generated for any \(i \in \iota \).

A stabilizer code \(C\) is a quantum low-density parity-check (qLDPC) code with parameters \((w, c)\) if:

1. Each check has weight bounded by \(w\): \(\forall \, i \in I,\; \operatorname {checkWeight}(C, i) \leq w\),

2. Each qubit participates in at most \(c\) checks: \(\forall \, v \in V,\; \operatorname {qubitDegree}(C, v) \leq c\).

For a Pauli operator \(P\) on the extended qubit system \(V \oplus E\), we define \(\operatorname {CommutesWithLogical’}(P)\) as the condition that \(\operatorname {zSupportRestricted}(G, P) = 0\).

For a Pauli operator \(P\) on the extended qubit system \(V \oplus E\), the Z-support restricted to vertices is defined as

This captures the Z-support on the vertex qubits only.

Given an ideal measurement outcome function \(\operatorname {ideal} : M \to \mathbb {Z}/2\mathbb {Z}\) and a set of time-faults, the observed outcome for measurement \(m\) is:

A time-fault on measurement \(m\) flips the observed outcome.

Given a Pauli operator \(P\) on \(V\), define its lift to the extended qubit space \(V \oplus E(G)\) by

i.e., \(P\) acts on vertex qubits as before and acts as the identity on all edge qubits.

Two Pauli operators \(P, Q \in \mathcal{P}_V\) have disjoint supports if \(\operatorname {supp}(P) \cap \operatorname {supp}(Q) = \emptyset \), i.e., \(\operatorname {supp}(P)\) and \(\operatorname {supp}(Q)\) are disjoint as finsets.

A family of Pauli operators \((P_i)_{i \in \operatorname {Fin}(m)}\) has pairwise disjoint supports if for all \(i \neq j\), we have \(\operatorname {DisjointSupports}(P_i, P_j)\).

A family of Pauli operators \((P_i)_{i \in \operatorname {Fin}(m)}\) satisfies the parallel LDPC bound with constant \(c\) if every qubit participates in at most \(c\) of the operators’ supports:

For a family of Pauli operators \((P_i)_{i \in \operatorname {Fin}(m)}\) and a qubit \(v \in V\), the qubit participation count is the number of operators whose support contains \(v\):

Two Pauli operators \(P, Q\) have same-type overlap if on every shared support qubit \(v \in \operatorname {supp}(P) \cap \operatorname {supp}(Q)\), either both have vanishing \(Z\)-component (\(P.\mathrm{zVec}(v) = 0 \land Q.\mathrm{zVec}(v) = 0\)) or both have vanishing \(X\)-component (\(P.\mathrm{xVec}(v) = 0 \land Q.\mathrm{xVec}(v) = 0\)).

Two Pauli operators \(P, Q\) have same-type X overlap if on every shared support qubit \(v \in \operatorname {supp}(P) \cap \operatorname {supp}(Q)\), both have vanishing \(Z\)-component: \(P.\mathrm{zVec}(v) = 0\) and \(Q.\mathrm{zVec}(v) = 0\).

Two Pauli operators \(P, Q\) have same-type Z overlap if on every shared support qubit \(v \in \operatorname {supp}(P) \cap \operatorname {supp}(Q)\), both have vanishing \(X\)-component: \(P.\mathrm{xVec}(v) = 0\) and \(Q.\mathrm{xVec}(v) = 0\).

A Pauli operator on qubits labeled by a type \(V\) is represented as a pair of binary vectors \((\mathtt{xVec}, \mathtt{zVec}) \in (\mathbb {Z}/2\mathbb {Z})^V \times (\mathbb {Z}/2\mathbb {Z})^V\). The pair \((x, z)\) represents the Pauli operator \(\bigotimes _v X_v^{x_v} Z_v^{z_v}\). At each site \(v\):

• \((0, 0)\) means the identity \(I\),

• \((1, 0)\) means \(X\),

• \((0, 1)\) means \(Z\),

• \((1, 1)\) means \(Y\) (up to phase).

The identity Pauli operator on qubits labeled by \(V\) is defined as \(\operatorname {id}(V) := (0, 0)\), i.e., the operator that acts as the identity on all qubits.

The product of two Pauli operators \(P = (x_P, z_P)\) and \(Q = (x_Q, z_Q)\) is defined by pointwise addition in \(\mathbb {Z}/2\mathbb {Z}\):

This captures the Pauli group multiplication up to phase.

Two Pauli operators \(P, Q : \operatorname {PauliOp}(V)\) commute (in the full Pauli group, including phases) if their symplectic inner product vanishes:

For a qubit label \(v \in V\), the Pauli-\(X\) operator acting on qubit \(v\) is defined as \(X_v := (\delta _v, 0)\), where \(\delta _v\) is the indicator function that is \(1\) at \(v\) and \(0\) elsewhere.

For a qubit label \(v \in V\), the Pauli-\(Y\) operator acting on qubit \(v\) is defined as \(Y_v := (\delta _v, \delta _v)\), representing \(X_v Z_v\) up to phase.

For a qubit label \(v \in V\), the Pauli-\(Z\) operator acting on qubit \(v\) is defined as \(Z_v := (0, \delta _v)\), where \(\delta _v\) is the indicator function that is \(1\) at \(v\) and \(0\) elsewhere.

For a finite set \(S \subseteq V\), the product of Pauli-\(X\) operators over \(S\) is

where \(\mathbf{1}_S(v) = 1\) if \(v \in S\) and \(0\) otherwise.

For a finite set \(S \subseteq V\), the product of Pauli-\(Z\) operators over \(S\) is

where \(\mathbf{1}_S(v) = 1\) if \(v \in S\) and \(0\) otherwise.

The full support of a Pauli operator \(P = (x, z)\) is the set of sites where \(P\) acts non-trivially:

The \(X\)-type support of a Pauli operator \(P = (x, z)\) is the set of sites where \(P\) acts via \(X\) or \(Y\):

The \(Z\)-type support of a Pauli operator \(P = (x, z)\) is the set of sites where \(P\) acts via \(Y\) or \(Z\):

Let \(V\) be a finite type. The symplectic inner product of two Pauli operators \(P, Q : \operatorname {PauliOp}(V)\) is defined as

This determines commutation in the full Pauli group: \(P\) and \(Q\) commute if and only if \(\langle P,Q\rangle _{\mathrm{symp}} = 0\).

The weight of a Pauli operator \(P\) is the number of qubits on which it acts non-trivially:

Given code distance \(d\) and a time step \(t \in \mathbb {N}\), the function \(\operatorname {phaseOf}(d, t)\) determines which phase \(t\) belongs to:

A Phase 3 measurement label for check set \(J\), edge set \(E\), and code distance \(d\) is one of:

1. \(\mathtt{edgeZ}(e)\): The \(Z_e\) measurement on edge qubit \(e \in E\) to ungauge.

2. \(\mathtt{originalCheck}(j, r)\): Original check \(j \in J\) measured in round \(r \in \operatorname {Fin}(d)\).

A Phase 1 measurement label for a code with check index set \(J\) and code distance \(d\) is a pair

recording which original stabilizer check \(j \in J\) is measured in which round \(r \in \{ 0, \ldots , d-1\} \).

The adjacency relation for the bridge graph on \(V \oplus V\). Two vertices \(p, q \in V \oplus V\) are adjacent if:

• Both in copy 1 (\(\operatorname {inl}(v)\), \(\operatorname {inl}(w)\)): \(G.\operatorname {Adj}(v, w)\),

• Both in copy 2 (\(\operatorname {inr}(v)\), \(\operatorname {inr}(w)\)): \(G.\operatorname {Adj}(v, w)\),

• Across copies (\(\operatorname {inl}(v)\), \(\operatorname {inr}(w)\) or vice versa): \(v = w\) and \(v \in \operatorname {bridges}\).

The bridge graph: two copies of \(G\) on vertex set \(V \oplus V\), connected by bridge edges at specified vertices in \(\operatorname {bridges} \subseteq V\).

The graph homomorphism \(G \to \operatorname {BridgeGraph}(G, \operatorname {bridges})\) embedding \(G\) as copy 1, via \(v \mapsto \operatorname {inl}(v)\). Paths in \(G\) correspond to paths in the bridge graph within copy 1.

The graph homomorphism \(G \to \operatorname {BridgeGraph}(G, \operatorname {bridges})\) embedding \(G\) as copy 2, via \(v \mapsto \operatorname {inr}(v)\).

The grid graph connecting two boundary edges with \(D\) columns of dummy ancillas. Column \(0\) is boundary \(1\), column \(D+1\) is boundary \(2\), and columns \(1, \ldots , D\) are dummy ancillas. This is a simple graph on \(\mathrm{Fin}\, n \times \mathrm{Fin}\, (D+2)\).

The adjacency relation for the grid graph on \(n \times (D+2)\) vertices. Vertices are \(\mathrm{Fin}\, n \times \mathrm{Fin}\, (D+2)\). Two vertices \(p = (r_1, c_1)\) and \(q = (r_2, c_2)\) are adjacent if \(p \neq q\) and either:

1. Horizontal: \(r_1 = r_2\) and \(|c_1 - c_2| = 1\) (same row, adjacent columns), or

2. Vertical: \(c_1 = c_2\) and \(|r_1 - r_2| = 1\) (same column, adjacent rows).

The adjacency relation for the ladder graph on \(2n\) vertices. The vertex set is \(\mathrm{Bool} \times \mathrm{Fin}\, n\). Two vertices \(p = (b_1, i)\) and \(q = (b_2, j)\) are adjacent if \(p \neq q\) and either:

1. Rung: \(b_1 \neq b_2\) and \(i = j\) (same position, different boundary), or

2. Rail: \(b_1 = b_2\) and \(|i - j| = 1\) (same boundary, consecutive positions).

The ladder graph connecting two boundary qubit sets of size \(n\). It is a simple graph on the vertex set \(\mathrm{Bool} \times \mathrm{Fin}\, n\) (\(2n\) vertices total), with adjacency given by \(\operatorname {ladderAdj}\): edges consist of rungs (across boundaries) and rails (within each boundary).

A repeated measurement detector is formed from two consecutive measurements \(m_1 \neq m_2\) of the same stabilizer check with common ideal outcome \(o \in \mathbb {Z}/2\mathbb {Z}\). The detector has:

• measurements \(= \{ m_1, m_2\} \),

• ideal outcome \(f(m) = o\) if \(m = m_1\) or \(m = m_2\), and \(0\) otherwise.

The detector constraint holds because \(o + o = 0\) in \(\mathbb {Z}/2\mathbb {Z}\).

The graph homomorphism \(G_{\mathrm{dummy}} \to \operatorname {ShorGraph}(W, G_{\mathrm{dummy}})\) given by \(v \mapsto \operatorname {inr}(v)\), which maps edges of \(G_{\mathrm{dummy}}\) to dummy subgraph edges of the Shor graph.

The dummy product \(\prod _{d \in D} X_d\) on dummy qubits only. Formally, \(\operatorname {xVec}(\operatorname {inl}(i)) = 0\), \(\operatorname {xVec}(\operatorname {inr}(i)) = 1\), and \(\operatorname {zVec} = 0\).

The Shor-style gauging graph on \(2W\) vertices. It is a simple graph on \(\operatorname {ShorVertex}(W)\) whose adjacency is given by \(\operatorname {shorGraphAdj}\), with symmetry established by shorGraphAdj_symm and irreflexivity by shorGraphAdj_irrefl. Its edges consist of \(W\) pairing edges \(\{ (\operatorname {inl}(i), \operatorname {inr}(i))\} \) plus the dummy subgraph edges.

The adjacency relation for the Shor-style gauging graph. Two vertices \(p, q\) are adjacent if \(p \neq q\) and one of the following holds:

1. Pairing edge: there exists \(i \in \operatorname {Fin}(W)\) with \(p = \operatorname {inl}(i)\) and \(q = \operatorname {inr}(i)\) (or vice versa), connecting support qubit \(i\) to dummy vertex \(d_i\).

2. Dummy subgraph edge: there exist \(i, j \in \operatorname {Fin}(W)\) with \(p = \operatorname {inr}(i)\), \(q = \operatorname {inr}(j)\), and \(i \sim j\) in \(G_{\mathrm{dummy}}\).

The logical operator \(L'\) on the Shor graph vertex set:

defined as the Pauli operator with \(\operatorname {xVec}(v) = 1\) for all \(v\) and \(\operatorname {zVec} = 0\). This is the extended logical from Rem 10 with \(V = D = \operatorname {Fin}(W)\).

The support-restricted logical operator: \(L\) acts as \(X\) on all \(\operatorname {inl}\) qubits (support qubits) and as \(I\) on all \(\operatorname {inr}\) qubits (dummy qubits). Formally, \(\operatorname {xVec}(\operatorname {inl}(i)) = 1\), \(\operatorname {xVec}(\operatorname {inr}(i)) = 0\), and \(\operatorname {zVec} = 0\).

The vertex type for the Shor-style gauging graph is \(\operatorname {Fin}(W) \oplus \operatorname {Fin}(W)\), representing support qubits and dummy qubits respectively. The total vertex count is \(2W\).

The edge boundary of a vertex subset \(S\) in a simple graph \(G = (V, E)\) is the set of edges with exactly one endpoint in \(S\). Formally,

where \(e_{\mathrm{set}}\) denotes the underlying two-element set of the edge \(e\).

A graph \(G\) is a \(c\)-expander if \(0 {\lt} c\) and \(c \le h(G)\).

Given a Pauli operator \(L'\) on \(V \oplus E\) and a function \(c : V \to \mathbb {Z}/2\mathbb {Z}\), the cleaned operator is defined by

Given a Pauli operator \(P\) on \(V \oplus E\), the edge X-support is the function \(\operatorname {edgeXSupport}(P) : E(G) \to \mathbb {Z}/2\mathbb {Z}\) defined by

Multiplication of pure-Z edge operators satisfies:

Given a Pauli operator \(P\) on the extended qubit space \(V \oplus E\), the restriction to vertex qubits \(\operatorname {restrictToV}(P)\) is the Pauli operator on \(V\) defined by

A space-fault (or space error) on a qubit set \(Q\) at times \(T\) is a structure consisting of:

• a qubit \(q \in Q\) where the error occurs,

• a time \(t \in T\) at which the error occurs,

• an \(X\)-component \(x \in \mathbb {Z}/2\mathbb {Z}\) (equal to \(1\) if the error has an \(X\) or \(Y\) component, \(0\) otherwise),

• a \(Z\)-component \(z \in \mathbb {Z}/2\mathbb {Z}\) (equal to \(1\) if the error has a \(Z\) or \(Y\) component, \(0\) otherwise),

• a nontriviality condition: \(x \neq 0\) or \(z \neq 0\).

This encodes a single-qubit Pauli error (\(X\), \(Y\), or \(Z\)) at a specific qubit and time.

The full outcome-preserving predicate for the fault-tolerant gauging procedure. A spacetime fault \(F\) preserves the outcome if both:

1. The gauging sign \(\sigma \) is preserved (no time-logical effect), i.e., \(\operatorname {PreservesGaugingSign}(\mathrm{proc}, F)\), AND

2. The net Pauli error at \(t_i\) is in the deformed stabilizer group (no space-logical effect), i.e., \(F.\operatorname {pauliErrorAt}(\mathrm{proc}.\mathrm{phase2Start}) \in \mathcal{S}(\text{deformedCode})\).

This captures the paper’s Def 11: a spacetime stabilizer leaves both the classical measurement record and the quantum code state unchanged.

A spacetime logical fault under the full outcome predicate: the fault is syndrome-free and changes the outcome (either flips the gauging sign or applies a nontrivial logical operator to the code state). Formally, \(\operatorname {IsFullGaugingLogicalFault}(\mathrm{proc}, F) := \operatorname {IsGaugingLogicalFault}(\mathrm{proc}, \mathrm{proc}.\mathrm{detectorOfIndex}, \operatorname {FullOutcomePreserving}(\mathrm{proc}), F)\).

A spacetime stabilizer under the full outcome predicate: the fault is syndrome-free and preserves both the gauging sign and the code state. Formally, \(\operatorname {IsFullGaugingStabilizer}(\mathrm{proc}, F) := \operatorname {IsGaugingStabilizer}(\mathrm{proc}, \mathrm{proc}.\mathrm{detectorOfIndex}, \operatorname {FullOutcomePreserving}(\mathrm{proc}), F)\).

A space-only logical fault: a spacetime fault \(F\) such that

1. \(F\) is pure-space (no time-faults),

2. all space-faults are concentrated at time \(t_i\): for all \(t \neq \mathrm{proc}.\mathrm{phase2Start}\), \(F.\operatorname {spaceFaultsAt}(t) = \emptyset \),

3. the composite Pauli error at \(t_i\) is a nontrivial logical of the deformed code: \(\operatorname {isLogicalOp}(\text{deformedCode}, F.\operatorname {pauliErrorAt}(t_i))\).

A time-only logical fault: a spacetime fault \(F\) such that

1. \(F\) is pure-time (no space-faults),

2. \(F\) is syndrome-free in the gauging procedure,

3. \(F\) flips the gauging sign \(\sigma \).

The deformed stabilizer code at the gauging time \(t_i\), constructed from the fault-tolerant gauging procedure’s data. Given a procedure \(\mathrm{proc}\), the deformed code is defined as the deformed stabilizer code built from the procedure’s deformed data and cycle parity, using the commutativity of the original checks.

A spacetime fault on qubit set \(Q\), time set \(T\), and measurement set \(M\) is a structure consisting of:

• a finite set \(\texttt{spaceFaults} \subseteq \operatorname {Finset}(\operatorname {SpaceFault}(Q, T))\) of space-faults,

• a finite set \(\texttt{timeFaults} \subseteq \operatorname {Finset}(\operatorname {TimeFault}(M))\) of time-faults.

This represents a collection of Pauli errors on qubits at specific times together with measurement errors.

The set of active times of a spacetime fault \(F\) is the image of the space-faults under the time projection:

The set of affected measurements of a spacetime fault \(F\) is the image of the time-faults under the measurement projection:

The set of affected qubits of a spacetime fault \(F\) is the image of the space-faults under the qubit projection:

The composition of two spacetime faults \(F_1\) and \(F_2\) is defined via the symmetric difference:

This captures the fact that applying the same error twice cancels it, and flipping an outcome twice restores it.

The empty spacetime fault is the fault-free configuration \((\emptyset , \emptyset )\), consisting of no space-faults and no time-faults.

The equivalent space-fault view of an initialization error on qubit \(q\) at time \(t\): this is \(\operatorname {ofSpaceFault}(\langle q, t, 1, 0, \cdot \rangle )\), representing a perfect initialization followed by a Pauli \(X\) error (since \(x\)-component is \(1\) and \(z\)-component is \(0\)).

An initialization fault for initialization measurement \(m\) is the spacetime fault \(\operatorname {ofTimeFault}(\langle m \rangle )\), modeling the initialization error as a time-fault on the measurement associated with the initialization.

A spacetime fault \(F\) is pure-space if it has no time-faults: \(\texttt{timeFaults}(F) = \emptyset \).

A spacetime fault \(F\) is pure-time if it has no space-faults: \(\texttt{spaceFaults}(F) = \emptyset \).

A spacetime fault \(F\) is trivial if \(F = \operatorname {empty}\), i.e., it contains no faults at all.

Given a single space-fault \(f\), the spacetime fault \(\operatorname {ofSpaceFault}(f) = (\{ f\} , \emptyset )\) consists of that single space-fault and no time-faults.

Given a single time-fault \(f\), the spacetime fault \(\operatorname {ofTimeFault}(f) = (\emptyset , \{ f\} )\) consists of no space-faults and that single time-fault.

The composite Pauli error at time \(t\) of a spacetime fault \(F\) on the qubit system \(Q\) is the Pauli operator \(P \in \operatorname {PauliOp}(Q)\) defined by:

The sums are taken in \(\mathbb {Z}/2\mathbb {Z}\).

The space component of a spacetime fault \(F\) is the spacetime fault \((\texttt{spaceFaults}(F), \emptyset )\), keeping only the space-faults.

The space-faults at time \(t\) of a spacetime fault \(F\) is the subset of space-faults whose time field equals \(t\):

The space weight of a spacetime fault \(F\) is \(\operatorname {spaceWeight}(F) = |\texttt{spaceFaults}(F)|\).

The time component of a spacetime fault \(F\) is the spacetime fault \((\emptyset , \texttt{timeFaults}(F))\), keeping only the time-faults.

The time weight of a spacetime fault \(F\) is \(\operatorname {timeWeight}(F) = |\texttt{timeFaults}(F)|\).

The weight of a spacetime fault \(F\) is the total number of individual faults:

Given a fault-tolerant gauging procedure \(\mathrm{proc}\), a collection of detectors indexed by \(\operatorname {DetectorIndex}\), and an outcome-preserving predicate, the set of gauging logical fault weights is

The gauging spacetime fault-distance is

Given a collection of detectors indexed by \(I\) and an outcome-preserving predicate, the set of logical fault weights is

The spacetime fault-distance is

where \(\inf \) is the infimum over natural numbers (returning \(0\) for the empty set).

A fault flips the gauging sign if the sign flip indicator equals \(1\):

The sign flip indicator for the fault-tolerant gauging procedure is defined as the parity of time-faults that affect Gauss’s law measurements:

computed in \(\mathbb {Z}/2\mathbb {Z}\). The gauging sign \(\sigma = \sum _v \varepsilon _v\), and a time-fault on a Gauss measurement flips one \(\varepsilon _v\).

A gauging logical fault is a spacetime fault in the gauging procedure that is syndrome-free AND changes the outcome:

A gauging stabilizer is a spacetime fault in the gauging procedure that is syndrome-free AND preserves the outcome:

A spacetime fault \(F\) changes the outcome if it is not outcome-preserving:

A spacetime fault \(F\) is outcome-preserving with respect to a predicate \(\operatorname {outcomePreserving}\) if \(\operatorname {outcomePreserving}(F)\) holds. This means the net effect of \(F\) on the procedure is trivial: it preserves both the measurement sign and the logical information in the post-measurement state.

A spacetime logical fault is a spacetime fault \(F\) satisfying:

1. \(\operatorname {IsSyndromeFree}(\delta , F)\): No detector is violated (syndrome is empty).

2. \(\operatorname {IsOutcomeChanging}(F)\): The fault changes the measurement result or applies a non-trivial logical operator to the post-measurement state.

A spacetime stabilizer is a spacetime fault \(F\) satisfying:

1. \(\operatorname {IsSyndromeFree}(\delta , F)\): No detector is violated (syndrome is empty).

2. \(\operatorname {IsOutcomePreserving}(F)\): The fault preserves both the measurement result and the logical information in the post-measurement state.

A spacetime fault \(F\) is syndrome-free with respect to a collection of detectors \((\delta _i)_{i \in I}\) if the syndrome is empty, i.e.,

Equivalently, no detector is violated by the time-faults of \(F\).

A spacetime fault \(F\) is syndrome-free in the gauging procedure if no detector from the spacetime code is violated:

Here the detector index type is the specialized \(\operatorname {DetectorIndex}\; V\; C\; J\; G.\! \operatorname {edgeSet}\; d\) from the fault-tolerant gauging procedure.

A fault preserves the gauging sign if the sign flip indicator equals \(0\):

An initialization fault \(+ X_e\) generator is a structure \((\mathsf{IsInitXeGen}\ \mathrm{proc}\ e\ F)\) for an edge \(e\) and spacetime fault \(F\), consisting of a \(|0\rangle _e\) initialization fault at time \(t_i - \tfrac {1}{2}\) paired with an \(X_e\) Pauli fault at the gauging start time \(t_i\). Formally:

1. \(F.\mathrm{timeFaults} = \{ \langle \mathrm{edgeInit}\ e \rangle \} \),

2. \(F.\mathrm{pauliErrorAt}(\mathrm{phase2Start}) = X_e\),

3. For all \(t' \neq \mathrm{phase2Start}\), \(F.\mathrm{spaceFaultsAt}(t') = \emptyset \).

Together, the initialization fault and \(X_e\) cancel in every detector involving edge \(e\).

A spacetime fault \(F\) is a listed generator \((\mathsf{IsListedGenerator}\ \mathrm{proc}\ F)\) if it falls into one of the following categories, organized by time phase:

1. Phase 1 & 3 – Original check: \(F\) is a space stabilizer generator for an original check \(\tilde{s}_j\) at time \(t\) with \(t {\lt} t_i\) or \(t \geq t_o\).

2. Phase 1 & 3 – Time-propagating: \(F\) is a time-propagating generator with Pauli \(P\) at time \(t\) with \(t {\lt} t_i\) or \(t \geq t_o\).

3. Phase 2 – Deformed check: \(F\) is a space stabilizer generator for a deformed check \(\mathrm{allChecks}(\mathrm{ci})\) at time \(t\) with \(t_i {\lt} t {\lt} t_o\).

4. Phase 2 – Time-propagating \(X_v\): at time \(t\) with \(t_i \leq t {\lt} t_o\).

5. Phase 2 – Time-propagating \(Z_v\): at time \(t\) with \(t_i \leq t {\lt} t_o\).

6. Phase 2 – Time-propagating \(X_e\): at time \(t\) with \(t_i \leq t {\lt} t_o\).

7. Phase 2 – Time-propagating \(Z_e\): at time \(t\) with \(t_i \leq t {\lt} t_o\).

8. Gauging (\(t = t_i\)) – Original check \(s_j\): space stabilizer at \(t_i\).

9. Gauging (\(t = t_i\)) – \(Z_e\): space stabilizer at \(t_i\).

10. Gauging (\(t = t_i\)) – Init \(+ X_e\): initialization fault paired with \(X_e\).

11. Gauging (\(t = t_i\)) – \(Z_e + A_v\): \(Z_e\) at \(t_i + 1\) with \(A_v\) measurement faults.

12. Ungauging (\(t = t_o\)) – Deformed check: space stabilizer at \(t_o\).

13. Ungauging (\(t = t_o\)) – Readout \(X_e\): \(X_e\) paired with \(Z_e\) readout fault.

14. Ungauging (\(t = t_o\)) – Bare \(Z_e\): space stabilizer at \(t_o\).

15. Ungauging (\(t = t_o\)) – \(Z_e + A_v\): \(Z_e\) at \(t_o - 1\) with \(A_v\) measurement faults.

16. Ungauging (\(t = t_o\)) – Time-propagating: at the \(t_o\) boundary.

A readout \(X_e\) generator is a structure \((\mathsf{IsReadoutXeGen}\ \mathrm{proc}\ e\ F)\) for an edge \(e\) and spacetime fault \(F\), consisting of Pauli \(X_e\) at ungauging time \(t_o\) paired with a \(Z_e\) readout measurement fault at \(t_o + \tfrac {1}{2}\). Formally:

1. \(F.\mathrm{timeFaults} = \{ \langle \mathrm{phase3}\ (\mathrm{edgeZ}\ e) \rangle \} \),

2. \(F.\mathrm{pauliErrorAt}(\mathrm{phase3Start}) = X_e\),

3. For all \(t' \neq \mathrm{phase3Start}\), \(F.\mathrm{spaceFaultsAt}(t') = \emptyset \).

The \(X_e\) flips the \(Z_e\) eigenvalue, and the \(Z_e\) readout measurement fault compensates, so the correct \(Z_e\) value is effectively recorded.

A space-only stabilizer generator is a structure \((\mathsf{IsSpaceStabilizerGen}\ \mathrm{proc}\ P\ t\ F)\) asserting that a spacetime fault \(F\) consists of a single check operator \(P\) applied as an error at time \(t\), with no measurement faults. Formally:

1. \(F.\mathrm{timeFaults} = \emptyset \),

2. \(F.\mathrm{pauliErrorAt}(t) = P\),

3. For all \(t' \neq t\), \(F.\mathrm{spaceFaultsAt}(t') = \emptyset \).

This is used for: original checks \(s_j\), deformed checks \(\tilde{s}_j / A_v / B_p\), and \(Z_e\) at initialization or readout times.

A time-propagating generator is a structure \((\mathsf{IsTimePropagatingGen}\ \mathrm{proc}\ P\ t\ F)\) asserting that \(F\) has Pauli error \(P\) at times \(t\) and \(t+1\), together with measurement faults on all checks that anticommute with \(P\) at time \(t + \tfrac {1}{2}\). Formally:

1. \(F.\mathrm{pauliErrorAt}(t) = P\),

2. \(F.\mathrm{pauliErrorAt}(t+1) = P\),

3. For all \(t' \neq t\) and \(t' \neq t+1\), \(F.\mathrm{spaceFaultsAt}(t') = \emptyset \),

4. \(F\) is syndrome-free for the gauging procedure.

The measurement faults ensure syndrome-freeness: each detector spanning time \(t + \tfrac {1}{2}\) has two violations (one from the Pauli error, one from the measurement fault) that cancel via \((-1) \times (-1) = +1\). The net Pauli effect is \(P \cdot P = I\), so the logical outcome is preserved.

A \(Z_e + A_v\) measurement fault generator is a structure \((\mathsf{IsZeAvMeasGen}\ \mathrm{proc}\ e\ t\ r\ F)\) for an edge \(e\), time \(t\), and round \(r\). It consists of Pauli \(Z_e\) at time \(t\) together with \(A_v\) measurement faults for both endpoints \(v \in e\) at measurement round \(r\). Formally:

1. \(F.\mathrm{pauliErrorAt}(t) = Z_e\),

2. For all \(t' \neq t\), \(F.\mathrm{spaceFaultsAt}(t') = \emptyset \),

3. \(F.\mathrm{timeFaults}\) equals the image of the set of vertices \(v \in e\) under the map \(v \mapsto \langle \mathrm{phase2}\ (\mathrm{gaussLaw}\ v\ r) \rangle \).

Since \(Z_e\) anticommutes with \(A_v\) for exactly the two endpoints \(v \in e\), the measurement faults cancel the two detector violations.

A stabilizer code on qubits labeled by a finite type \(V\) consists of:

• A finite index type \(I\) for stabilizer checks,

• A map \(\operatorname {check} : I \to \operatorname {PauliOp}(V)\) assigning a Pauli operator to each check index,

• A commutativity condition: for all \(i, j \in I\), \(\operatorname {PauliCommute}(\operatorname {check}(i), \operatorname {check}(j))\).

The centralizer set of a stabilizer code \(C\) is the set of all Pauli operators in the centralizer:

The weight of the \(i\)-th stabilizer check of a code \(C\) is the weight of the corresponding Pauli operator:

The code distance of a stabilizer code \(C\) is the minimum weight of a non-trivial logical operator:

If no logical operators exist, this returns \(0\).

A stabilizer code \(C\) has parameters \([\! [n, k, d]\! ]\) if:

1. \(|V| = n\) (the number of physical qubits is \(n\)),

2. \(n - \operatorname {numChecks}(C) = k\) (the number of encoded logical qubits is \(k\)),

3. \(d(C) = d\) (the code distance is \(d\)).

A Pauli operator \(P\) is in the centralizer of a stabilizer code \(C\) if it commutes (in the full Pauli group) with every stabilizer check:

A Pauli operator \(P\) is a non-trivial logical operator of a stabilizer code \(C\) if:

1. \(P\) is in the centralizer: \(\operatorname {inCentralizer}(C, P)\),

2. \(P\) is not in the stabilizer group: \(P \notin S\),

3. \(P\) is not the identity: \(P \neq 1\).

The number of stabilizer checks of a stabilizer code \(C\) is

The number of physical qubits of a stabilizer code \(C\) on qubit type \(V\) is

The qubit degree of a qubit \(v \in V\) in a stabilizer code \(C\) is the number of checks that act non-trivially on \(v\):

The stabilizer group \(S\) of a stabilizer code \(C\) is the subgroup of \(\operatorname {PauliOp}(V)\) generated by the set of checks \(\{ \operatorname {check}(i) \mid i \in I\} \):

A stabilizer code \(C\) is CSS (Calderbank–Shor–Steane) if every check is either purely \(X\)-type or purely \(Z\)-type. Formally, for every check index \(i\),

The perfect matching graph \(G\) on \(\operatorname {Fin}(n) \oplus \operatorname {Fin}(n)\), defined as the simple graph with adjacency relation \(\operatorname {matchingGraphAdj}(n)\).

The adjacency relation for the perfect matching graph on vertex set \(\operatorname {Fin}(n) \oplus \operatorname {Fin}(n)\): data qubit \(\operatorname {inl}(i)\) is adjacent to ancilla qubit \(\operatorname {inr}(i)\) (and vice versa), with no other edges. Formally, \(p \sim q\) iff there exists \(i : \operatorname {Fin}(n)\) such that \((p = \operatorname {inl}(i) \land q = \operatorname {inr}(i))\) or \((p = \operatorname {inr}(i) \land q = \operatorname {inl}(i))\).

The X-type check indices of a stabilizer code \(C\) are those indices \(i\) such that \((\mathtt{check}(i)).\mathtt{zVec} = 0\) and \((\mathtt{check}(i)).\mathtt{xVec} \neq 0\).

The incidence relation for state preparation: qubit \(q\) is incident to Z-check \(i\) if and only if the check has Z-action at \(q\), i.e., \((\mathtt{checks}(i)).\mathtt{zVec}(q) \neq 0\).

The Z-type check indices of a stabilizer code \(C\) are those indices \(i\) such that \((\mathtt{check}(i)).\mathtt{xVec} = 0\) and \((\mathtt{check}(i)).\mathtt{zVec} \neq 0\).

Let \(I\) be a finite type indexing a collection of detectors \(\{ D_i\} _{i \in I}\), and let \(F\) be a spacetime fault. The syndrome fault set of \(F\) with respect to the detectors is the finset of detector indices that are violated by \(F\):

Since detectors depend only on measurement outcomes and only time-faults flip outcomes, the syndrome is determined by the time-fault component of \(F\).

The syndrome vector of a spacetime fault \(F\) with respect to detectors \(\{ D_i\} _{i \in I}\) is the binary vector \(s \colon I \to \mathbb {Z}_2\) defined by

This is the \(\mathbb {Z}_2^m\) representation of the syndrome.

A time-fault (or measurement error) on a measurement set \(M\) is a structure consisting of a single field:

• a measurement \(m \in M\) whose outcome is reported incorrectly (i.e., \(+1\) is reported as \(-1\) or vice versa).

By convention, state mis-initialization faults are also modeled as time-faults: initializing \(|0\rangle \) but obtaining \(|1\rangle \) is equivalent to a perfect initialization followed by a Pauli \(X\) error.

The Gauss fault count for vertex \(v\) in a spacetime fault \(F\) is the number of rounds \(r \in \operatorname {Fin}(d)\) at which the \(A_v\) measurement at round \(r\) is a time-fault:

For a vertex \(v \in V\), the Gauss measurement faults \(\operatorname {gaussMeasFaults}(v)\) is the set of time-faults corresponding to the \(A_v\) measurement at all \(d\) rounds of Phase 2:

The Gauss string fault for vertex \(v\) is the spacetime fault \((\emptyset , \operatorname {gaussMeasFaults}(v))\) with no space-faults and time-faults given by the \(A_v\) measurement string.

A spacetime fault \(F\) is a pure-time fault if it has no space-faults, i.e., \(F\) satisfies \(F.\mathrm{isPureTime}\).

A spacetime fault \(F\) is a pure-time gauging logical fault if it is both a pure-time fault and a gauging logical fault:

The set of weights of pure-time gauging logical faults:

The time fault-distance is the infimum of the set of pure-time logical fault weights:

The lift map \(\operatorname {liftVL}\) is injective.

If \(g \in \ker (\operatorname {hyperCoboundaryMap}(\operatorname {coreIncident}))\), then \(\operatorname {liftVL}(g) \in \ker (\operatorname {restrictedCoboundaryMap})\).

For any Pauli operator \(P\) on \(V\),

The Z-support on vertices is additive under Pauli multiplication: for all \(v \in V\),

\(A_v\) acts nontrivially at vertex \(w\) if and only if \(w = v\).

\(A_v\) acts nontrivially at edge \(e\) if and only if \(v \in e\).

For any vertices \(v, w\), the \(X\)-component of \(A_v\) at vertex \(w\) is given by \((A_v)^X_{w} = \begin{cases} 1 & \text{if } w = v \\ 0 & \text{otherwise} \end{cases}\).

For any vertex \(v\) and edge \(e\), the \(X\)-component of \(A_v\) at edge \(e\) is \((A_v)^X_e = \begin{cases} 1 & \text{if } v \in e \\ 0 & \text{otherwise} \end{cases}\).

The deformed initialization detector for check \(j\) contains \(\texttt{phase2}(\texttt{deformed}(j, r_{\text{first}}))\).

For any edge \(e\) with \(\text{edgePath}(j, e) \neq 0\), the deformed initialization detector contains \(\texttt{edgeInit}(e)\).

The deformed initialization detector for check \(j\) contains \(\texttt{phase1}(j, r_{\text{last}})\).

The deformed ungauging detector for check \(j\) contains \(\texttt{phase2}(\texttt{deformed}(j, r_{\text{last}}))\).

For any edge \(e\) with \(\text{edgePath}(j, e) \neq 0\), the deformed ungauging detector for check \(j\) contains \(\texttt{phase3}(\texttt{edgeZ}(e))\).

The deformed ungauging detector for check \(j\) contains \(\texttt{phase3}(\texttt{originalCheck}(j, r_{\text{first}}))\).

For any check \(j\) with \(\text{edgePath}(j, e) \neq 0\), the edge initialization measurement \(\texttt{edgeInit}(e)\) is in the deformed initialization detector for \(j\).

For any cycle \(p\) containing edge \(e\), the edge initialization measurement \(\texttt{edgeInit}(e)\) is in the flux initialization detector for \(p\).

For any edge \(e\) in the cycle \(p\), the flux initialization detector contains the edge initialization measurement \(\texttt{edgeInit}(e)\).

The flux initialization detector for cycle \(p\) contains the measurement \(\texttt{phase2}(\texttt{flux}(p, r_{\text{first}}))\).

For any edge \(e\) in the cycle \(p\), the flux ungauging detector contains \(\texttt{phase3}(\texttt{edgeZ}(e))\).

The flux ungauging detector for cycle \(p\) contains the measurement \(\texttt{phase2}(\texttt{flux}(p, r_{\text{last}}))\).

For any Gauss outcomes, \(\mathtt{gaugingSign}(\mathit{gaussOutcomes}) = 0\) or \(\mathtt{gaugingSign}(\mathit{gaussOutcomes}) = 1\).

For any edge initialization \(\mathit{ei}\), \(\mathtt{measurementTime}(\mathtt{edgeInit}(\mathit{ei})) = d\).

For any Phase 1 measurement \(\mathit{pm}\), \(\mathtt{measurementTime}(\mathtt{phase1}(\mathit{pm})) {\lt} d\).

For any Phase 2 measurement \(\mathit{dm}\), \(d \le \mathtt{measurementTime}(\mathtt{phase2}(\mathit{dm}))\).

For any Phase 2 measurement \(\mathit{dm}\), \(\mathtt{measurementTime}(\mathtt{phase2}(\mathit{dm})) {\lt} 2d\).

For any Phase 3 measurement \(\mathit{pm}\), \(2d \le \mathtt{measurementTime}(\mathtt{phase3}(\mathit{pm}))\).

For any Phase 3 measurement \(\mathit{pm}\), \(\mathtt{measurementTime}(\mathtt{phase3}(\mathit{pm})) {\lt} 3d\).

Phase 1 measurements are covered by repeated or boundary detectors:

• If \(r + 1 {\lt} d\), then \(\texttt{phase1}(j, r)\) is in the Phase 1 repeated detector for \((j, r, r+1)\).

• If \(r + 1 = d\), then \(\texttt{phase1}(j, r)\) is in the deformed initialization detector for \(j\).

The duration of Phase 1 equals \(d\): \(\mathtt{phase2Start} = d\).

Phase 2 deformed measurements are covered by init, ungauge, or repeated detectors:

• If \(r = 0\), the measurement is in the deformed init detector.

• If \(r + 1 = d\), the measurement is in the deformed ungauge detector.

• If \(r + 1 {\lt} d\), the measurement is in a deformed repeated detector.

For any \(j \in J\) and round \(r\), \(\mathtt{phase2Operator}(\mathtt{deformed}(j, r)) = \text{deformedOriginalChecks}(G, \mathit{checks}, \mathit{deformedData}, j)\).

For any check \(j \in J\), round \(r\), and edge \(e \in E(G)\), the Phase 2 deformed check operator has zero \(X\)-component on edge qubit \(e\):

The duration of Phase 2 equals \(d\): \(\mathtt{phase3Start} - \mathtt{phase2Start} = d\).

Phase 2 flux measurements are covered by init, ungauge, or repeated detectors:

• If \(r = 0\), the measurement is in the flux init detector.

• If \(r + 1 = d\), the measurement is in the flux ungauge detector.

• If \(r + 1 {\lt} d\), the measurement is in a flux repeated detector.

For any \(p \in C\) and round \(r\), \(\mathtt{phase2Operator}(\mathtt{flux}(p, r)) = \text{fluxChecks}(G, \mathit{cycles}, p)\).

For any cycle \(p \in C\) and round \(r\), the Phase 2 flux operator has zero \(X\)-component:

Phase 2 Gauss measurements are covered by Gauss repeated detectors (assuming \(d \geq 2\)):

• If \(r + 1 {\lt} d\), then \(\texttt{phase2}(\texttt{gaussLaw}(v, r))\) is in the forward repeated detector.

• If \(0 {\lt} r\), then it is in the backward repeated detector pairing round \(r-1\) with \(r\).

For any \(v \in V\) and round \(r\), \(\mathtt{phase2Operator}(\mathtt{gaussLaw}(v, r)) = \text{gaussLawChecks}(G, v)\).

For any vertex \(v \in V\) and round \(r\), the Phase 2 Gauss’s law operator has zero \(Z\)-component:

We have \(\mathtt{phase2Start} \le \mathtt{phase3Start}\), i.e., \(d \le 2d\).

The duration of Phase 3 equals \(d\): \(\mathtt{procedureEnd} - \mathtt{phase3Start} = d\).

For any check \(j\) with \(\text{edgePath}(j, e) \neq 0\), the measurement \(\texttt{phase3}(\texttt{edgeZ}(e))\) is in the deformed ungauging detector for \(j\).

For any cycle \(p\) containing edge \(e\), the measurement \(\texttt{phase3}(\texttt{edgeZ}(e))\) is in the flux ungauging detector for \(p\).

Phase 3 original check measurements are covered:

• If \(r = 0\), the measurement is in the deformed ungauge detector.

• If \(0 {\lt} r\), the measurement is in a Phase 3 repeated detector pairing round \(r-1\) with \(r\).

We have \(\mathtt{phase3Start} \le \mathtt{procedureEnd}\), i.e., \(2d \le 3d\).

The total duration of the procedure is \(3d\): \(\mathtt{procedureEnd} = 3d\).

The byproduct correction at the base vertex \(v_0\) using the trivial walk is \(0\):

The byproduct correction operator has no \(Z\)-component:

The edge \(Z\) operator \(Z_e\) has no \(X\)-support:

The Gauss’s law operator \(A_v\) has no \(Z\)-support:

For an adjacency \(h : G.\mathrm{Adj}(u, v)\) and a walk \(p\) from \(v\) to \(w\), the walk parity of the extended walk \(\operatorname {cons}(h, p)\) satisfies:

The walk parity of the trivial (nil) walk at any vertex \(v\) is \(0\).

For a single-edge walk along adjacency \(h : G.\mathrm{Adj}(u, v)\),

For all \(p \in C\), \(B_p.\operatorname {xVec} = 0\).

For each vertex \(v \in V\),

For each edge \(e \in G.\operatorname {edgeSet}\),

For all \(v \in V\), \(A_v.\operatorname {zVec} = 0\).

For a vertex \(v \in V\) and an edge \(e \in G.\operatorname {edgeSet}\),

Each generator \(\text{generators}_i\) is in the \(\mathbb {Z}_2\) span.

If \(S\) and \(T\) are both \(\mathbb {Z}_2\)-generated by the generators, then \(S \mathbin {\triangle } T\) is also generated.

The existence of a boundary condition for \(P\) is equivalent to the Z-support on vertices being in the image of the boundary map:

The sum of \(\operatorname {zSupportOnVertices}\) of \(\operatorname {pauliZ}(v)\) equals \(1\):

If measurement \(m\) is affected by a time-fault (i.e., \(\langle m \rangle \in \texttt{faults}\)), then the observed outcome differs from the ideal outcome:

If measurement \(m\) is not affected by any time-fault (i.e., \(\langle m \rangle \notin \texttt{faults}\)), then the observed outcome equals the ideal outcome:

If measurement \(m\) is affected by a time-fault (i.e., \(\langle m \rangle \in \texttt{faults}\)), thenthe observed outcome is the ideal outcome plus \(1\):

If \(h(G) \geq 1\), then for any \(d \in \mathbb {N}\),

If \(d {\gt} 0\), \(h(G) {\gt} 0\), and \(h(G) {\lt} 1\), then

For any logical operator \(L'\) of the deformed code,

Let \(P\) be a Pauli operator on \(V\) and \(j\) a check index such that \(P\) commutes with the original check \(\operatorname {checks}(j)\). Then \(\operatorname {liftToExtended}(P)\) commutes with the deformed original check \(\operatorname {deformedOriginalChecks}(j)\).

For any Pauli operator \(P\) on \(V\) and any cycle index \(p\), the lifted operator commutes with the flux check:

For any Pauli operator \(P\) on \(V\) and vertex \(v\),

If \(P\) is a pure-\(X\) operator (i.e., \(P.\operatorname {zVec} = 0\)), then \(\operatorname {liftToExtended}(P)\) commutes with \(A_v\) for every vertex \(v \in V\).

For any Pauli operators \(P, Q\) on \(V\),

If \(P \neq \mathbf{1}\), then \(\operatorname {liftToExtended}(P) \neq \mathbf{1}\).

We have \(\operatorname {liftToExtended}(\mathbf{1}) = \mathbf{1}\).

For any Pauli operator \(P\) on \(V\) and vertex \(v \in V\),

For any Pauli operator \(P\) on \(V\),

For any Pauli operator \(P\) on \(V\),

For a Pauli operator \(P\) and vertex \(v\),

For a Pauli operator \(P\) and vertex \(v\),

For all Pauli operators \(P, Q, R\), we have \((P \cdot Q) \cdot R = P \cdot (Q \cdot R)\).

For all Pauli operators \(P, Q\), we have \(P \cdot Q = Q \cdot P\).

For all Pauli operators \(P\), we have \(P \cdot 1 = P\).

For all Pauli operators \(P\), we have \(P \cdot P = 1\).

For all Pauli operators \(P\), we have \(1 \cdot P = P\).

For any qubit label \(v\),

For any qubit label \(v\),

For any Pauli operator \(P\),

The full support of the identity operator is empty: \(S(\mathbb {1}) = \emptyset \).

The \(X\)-type support of the identity operator is empty: \(S_X(\mathbb {1}) = \emptyset \).

For any qubit label \(v\), the \(X\)-type support of \(X_v\) is \(\{ v\} \): \(S_X(X_v) = \{ v\} \).

For any qubit label \(v\), the \(X\)-type support of \(Y_v\) is \(\{ v\} \): \(S_X(Y_v) = \{ v\} \).

For any qubit label \(v\), the \(X\)-type support of \(Z_v\) is empty: \(S_X(Z_v) = \emptyset \).

For a finite set \(S\), the \(X\)-type support of \(\prod _{v \in S} X_v\) is \(S\) itself: \(S_X\! \left(\prod _{v \in S} X_v\right) = S\).

For a finite set \(S\), the \(X\)-type support of \(\prod _{v \in S} Z_v\) is empty: \(S_X\! \left(\prod _{v \in S} Z_v\right) = \emptyset \).

The \(Z\)-type support of the identity operator is empty: \(S_Z(\mathbb {1}) = \emptyset \).

For any qubit label \(v\), the \(Z\)-type support of \(X_v\) is empty: \(S_Z(X_v) = \emptyset \).

For any qubit label \(v\), the \(Z\)-type support of \(Y_v\) is \(\{ v\} \): \(S_Z(Y_v) = \{ v\} \).

For any qubit label \(v\), the \(Z\)-type support of \(Z_v\) is \(\{ v\} \): \(S_Z(Z_v) = \{ v\} \).

For a finite set \(S\), the \(Z\)-type support of \(\prod _{v \in S} X_v\) is empty: \(S_Z\! \left(\prod _{v \in S} X_v\right) = \emptyset \).

For a finite set \(S\), the \(Z\)-type support of \(\prod _{v \in S} Z_v\) is \(S\) itself: \(S_Z\! \left(\prod _{v \in S} Z_v\right) = S\).

The weight of the identity operator is zero: \(\operatorname {wt}(\mathbb {1}) = 0\).

If \(d \le t\) and \(t {\lt} 2d\), then \(\operatorname {phaseOf}(d, t) = \text{deformedCode}\).

If \(2d \le t\), then \(\operatorname {phaseOf}(d, t) = \text{postDeformation}\).

If \(t {\lt} d\), then \(\operatorname {phaseOf}(d, t) = \text{preDeformation}\).

For all \(p \in V \oplus V\), \(\neg \operatorname {bridgeAdj}(G, \operatorname {bridges}, p, p)\).

For all \(p, q \in V \oplus V\), if \(\operatorname {bridgeAdj}(G, \operatorname {bridges}, p, q)\) then \(\operatorname {bridgeAdj}(G, \operatorname {bridges}, q, p)\).

For \(v \in \operatorname {bridges}\), the bridge graph has an edge \(\operatorname {inl}(v) \sim \operatorname {inr}(v)\).

\(|V \oplus V| = 2|V|\).

If \(G.\operatorname {Adj}(v, w)\), then \((\operatorname {BridgeGraph}\, G\, \operatorname {bridges}).\operatorname {Adj}(\operatorname {inl}(v), \operatorname {inl}(w))\).

If \(G.\operatorname {Adj}(v, w)\), then \((\operatorname {BridgeGraph}\, G\, \operatorname {bridges}).\operatorname {Adj}(\operatorname {inr}(v), \operatorname {inr}(w))\).

\(|\mathrm{Fin}\, n \times \mathrm{Fin}\, (D+2)| = n \cdot (D + 2)\).

For \(i \in \mathrm{Fin}\, n\) and \(j, j' \in \mathrm{Fin}\, (D+2)\) with \(j + 1 = j'\), the pair \((i, j)\) and \((i, j')\) are adjacent in the grid graph.

For \(i, i' \in \mathrm{Fin}\, n\) and \(j \in \mathrm{Fin}\, (D+2)\) with \(i + 1 = i'\), the pair \((i, j)\) and \((i', j)\) are adjacent in the grid graph.

\(|\mathrm{Bool} \times \mathrm{Fin}\, n| = n + n\).

For all \(p \in \mathrm{Bool} \times \mathrm{Fin}\, n\), \(\neg \operatorname {ladderAdj}(p, p)\).

For all \(p, q \in \mathrm{Bool} \times \mathrm{Fin}\, n\), if \(\operatorname {ladderAdj}(p, q)\) then \(\operatorname {ladderAdj}(q, p)\).

\(|\mathrm{Bool} \times \mathrm{Fin}\, n| = 2n\).

For boundary \(b\) and positions \(i, j \in \mathrm{Fin}\, n\) with \(i + 1 = j\), the pair \((b, i)\) and \((b, j)\) are adjacent in the ladder graph.

For each \(i \in \mathrm{Fin}\, n\), the pair \((\mathrm{false}, i)\) and \((\mathrm{true}, i)\) are adjacent in the ladder graph.

For any vertex \(p\), \(\neg \operatorname {shorGraphAdj}(W, G_{\mathrm{dummy}}, p, p)\).

If \(\operatorname {shorGraphAdj}(W, G_{\mathrm{dummy}}, p, q)\) holds, then \(\operatorname {shorGraphAdj}(W, G_{\mathrm{dummy}}, q, p)\) holds.

If \(\bar{L}\) commutes with all deformed checks and has no X-support on edges, then \(\operatorname {restrictToV}(\bar{L})\) commutes with all original checks.

If \(\bar{L}\) commutes with the deformed check \(\tilde{s}_j\) and has no X-support on edges, then \(\operatorname {restrictToV}(\bar{L})\) commutes with the original check \(s_j\).

If \(\delta (c)(e) = L'.\mathbf{x}(\operatorname {inr}(e))\) for all edges \(e\), then

For any \(L'\) and \(c\):

For any Pauli operator \(L'\) on \(V \oplus E\), function \(c : V \to \mathbb {Z}/2\mathbb {Z}\), and edge \(e \in E(G)\):

where \(\delta \) denotes the coboundary map.

For any \(L'\), \(c\), and vertex \(v \in V\):

For any \(L'\) and \(c\):

For any \(c : V \to \mathbb {Z}/2\mathbb {Z}\):

If \(\delta (c) = \operatorname {edgeXSupport}(L')\), then

For any \(L'\) and \(c\):

The restriction of the logical operator \(L = \prod _q X_q\) on \(V \oplus E\) to vertex qubits equals \(\operatorname {logicalOpV}\):

For any \(c : V \to \mathbb {Z}/2\mathbb {Z}\):

Let \(\bar{L}\) be a Pauli operator on \(V \oplus E\) with \(\bar{L}.\mathbf{x}(\operatorname {inr}(e)) = 0\) for all edges \(e\). Then for any original check index \(j\):

where \(\tilde{s}_j\) denotes the deformed original check and \(s_j\) the original check.

For any \(L'\) and \(c\):

For a Pauli operator \(P\) on \(V \oplus E\):

For a Pauli operator \(P\) on \(V \oplus E\):

Let \(w, d, |S|, |\partial | \in \mathbb {N}\) and \(h \geq 0\) a real number. If:

1. \(w + |S| \geq d + |\partial |\),

2. \(h \cdot |S| \leq |\partial |\), and

3. \(|\partial | \leq w\),

then \(w \geq \min (h, 1) \cdot d\).

For any spacetime faults \(F_1, F_2, F_3\):