A time region in the gauging measurement procedure is one of:

• beforeGauging: \(t {\lt} t_i\) (original code),

• duringGauging: \(t_i {\lt} t {\lt} t_o\) (deformed code),

• afterGauging: \(t {\gt} t_o\) (original code),

• initialBoundary: \(t = t_i\),

• finalBoundary: \(t = t_o\).

A detector effect models the effect of a generator’s faults on a detector. It is a structure with three \(\mathbb {Z}_2\)-valued fields:

• \(\mathtt{pauliFlip\_ t} \in \mathbb {Z}_2\): flip from a Pauli at time \(t\) affecting the measurement at \(t + \tfrac {1}{2}\),

• \(\mathtt{pauliFlip\_ t1} \in \mathbb {Z}_2\): flip from a Pauli at time \(t+1\) affecting the measurement at \(t + \tfrac {3}{2}\),

• \(\mathtt{measFault} \in \mathbb {Z}_2\): flip from a measurement fault at \(t + \tfrac {1}{2}\).

The net effect on detector \(c^t\) (comparing measurements at \(t - \tfrac {1}{2}\) and \(t + \tfrac {1}{2}\)) is defined as

The measurement at \(t - \tfrac {1}{2}\) is unaffected, while the recorded outcome at \(t + \tfrac {1}{2}\) is flipped by both the Pauli at time \(t\) and the measurement fault.

The net effect on detector \(c^{t+1}\) (comparing measurements at \(t + \tfrac {1}{2}\) and \(t + \tfrac {3}{2}\)) is

A spacetime stabilizer generator is one of the following types:

For \(t {\lt} t_i\) and \(t {\gt} t_o\) (original code):

1. spaceStabilizer: a check operator \(s_j\) (or \(\tilde{s}_j\), \(A_v\), \(B_p\)) at time \(t\);

2. pauliPairOriginal: a Pauli \(P\) at time \(t\) and \(P\) at time \(t+1\), together with measurement faults on all anticommuting checks \(s_j\).

For \(t_i {\lt} t {\lt} t_o\) (deformed code):

1. vertexXPair: \(X_v\) at \(t\) and \(t+1\) with measurement faults on anticommuting \(\tilde{s}_j\);

2. vertexZPair: \(Z_v\) at \(t\) and \(t+1\) with measurement faults on \(A_v\) and anticommuting \(\tilde{s}_j\);

3. edgeXPair: \(X_e\) at \(t\) and \(t+1\) with measurement faults on \(B_p\) (for \(p \ni e\)) and anticommuting \(\tilde{s}_j\);

4. edgeZPair: \(Z_e\) at \(t\) and \(t+1\) with measurement faults on \(A_v\) (for \(v \in e\)).

For \(t = t_i\) (initial boundary):

1. initFaultPlusXe: initialization fault on \(|0\rangle _e\) plus \(X_e\) at time \(t\);

2. initialBoundaryZePair: \(Z_e\) at \(t+1\) with \(A_v\) measurement faults for \(v \in e\).

For \(t = t_o\) (final boundary):

1. finalBoundaryXePair: \(X_e\) at \(t\) with \(Z_e\) measurement fault;

2. finalBoundaryBareZe: bare \(Z_e\) at \(t\) (since \(Z|0\rangle = |0\rangle \));

3. finalBoundaryZePair: \(Z_e\) at \(t-1\) with \(A_v\) measurement faults for \(v \in e\).

The predicate \(\mathrm{generatorValidInRegion}(\mathrm{gen}, \mathrm{region})\) specifies which time regions a generator is valid in:

• spaceStabilizer with region \(r\): valid only in region \(r\);

• pauliPairOriginal: valid in beforeGauging or afterGauging;

• vertexXPair, vertexZPair, edgeXPair: valid in duringGauging or initialBoundary;

• edgeZPair: valid in duringGauging;

• initFaultPlusXe, initialBoundaryZePair: valid in initialBoundary;

• finalBoundaryXePair, finalBoundaryBareZe, finalBoundaryZePair: valid in finalBoundary.

The space stabilizer effect is the detector effect \((0, 0, 0)\): no flips, since a space stabilizer acts as the identity on the code space.

The Pauli pair effect on an anticommuting check is the detector effect \((1, 1, 1)\): the Pauli flips at both times \(t\) and \(t+1\), and the measurement fault flips the recorded outcome at \(t + \tfrac {1}{2}\).

The Pauli pair effect on a commuting check is the detector effect \((0, 0, 0)\): no flips.

The initialization fault plus \(X_e\) effect is the detector effect \((1, 0, 1)\): the initialization fault is equivalent to an \(X\) error, so \(X + X = I\).

The final boundary \(X_e\) pair effect is the detector effect \((1, 0, 1)\): \(X_e\) at time \(t\) with a \(Z_e\) measurement fault.

The bare \(Z_e\) effect is the detector effect \((0, 0, 0)\): since \(Z|0\rangle = |0\rangle \), the eigenvalue is \(+1\) and no detector is flipped.

The \(Z_e\) pair effect with \(A_v\) measurement faults is the detector effect \((1, 1, 1)\): the measurement faults are placed to cancel all detector effects.

A generator \(g\) has empty syndrome if, for every relevant detector, the net \(\mathbb {Z}_2\) effect is zero. Specifically:

• For spaceStabilizer: \(\mathrm{netEffect}_{c^t} = 0\) and \(\mathrm{netEffect}_{c^{t+1}} = 0\) using the space stabilizer effect;

• For Pauli pair generators (pauliPairOriginal, vertexXPair, vertexZPair, edgeXPair, edgeZPair): both anticommuting and commuting detector effects vanish at \(c^t\) and \(c^{t+1}\);

• For initFaultPlusXe: \(\mathrm{netEffect}_{c^t} = 0\);

• For boundary \(Z_e\) pair generators: both \(c^t\) and \(c^{t+1}\) effects vanish;

• For finalBoundaryXePair: \(\mathrm{netEffect}_{c^t} = 0\);

• For finalBoundaryBareZe: \(\mathrm{netEffect}_{c^t} = 0\).

The logical effect of a generator \(g\) is a value in \(\mathbb {Z}_2\) (\(0\) = trivial, \(1\) = nontrivial). For every generator type, \(\mathrm{logicalEffect}(g) = 0\):

• Stabilizers act as the identity on the code space;

• Pauli pairs cancel: \(P \cdot P = I\);

• Initialization fault plus \(X\) cancels;

• Boundary generators act on qubits being initialized or discarded.

A spacetime fault pattern consists of:

• A finite set of Pauli faults, indexed by (qubit location, time step, Pauli kind);

• A finite set of measurement faults, indexed by (check type, time step).

A fault pattern \(p\) has empty syndrome if for every detector \((c, t)\):

The net Pauli parity of a fault pattern \(p\) at qubit \(q\) is the number of Pauli faults at \(q\) modulo \(2\):

A value of \(0\) means an even number of Paulis (they cancel: \(P \cdot P = I\)), while \(1\) means a nontrivial Pauli remains.

A fault pattern \(p\) preserves logical information if either:

1. For every qubit \(q\), \(\mathrm{netPauliParity}(p, q) = 0\) (all Paulis cancel pairwise), or

2. \(p.\mathrm{pauliFaults} = \emptyset \) (the pattern is a pure space stabilizer with no explicit Pauli faults).

A local spacetime stabilizer is a spacetime fault pattern \(p\) that:

1. has bounded support (automatic since fault sets are finite),

2. has empty syndrome, and

3. preserves logical information.

The function \(\mathrm{generatorToPattern}\) converts each generator type to an explicit fault pattern. For example:

• spaceStabilizer: empty Pauli faults, empty measurement faults;

• pauliPairOriginal(\(q\), \(P\), \(t\), \(S\)): Pauli faults \(\{ (q, t, P), (q, t{+}1, P)\} \), measurement faults \(\{ (s_j, t) : j \in S\} \);

• vertexXPair(\(v\), \(t\), \(S\)): Pauli faults \(\{ (\mathrm{vertex}(v), t, X), (\mathrm{vertex}(v), t{+}1, X)\} \) with deformed check measurement faults;

• initFaultPlusXe(\(e\), \(t\)): single Pauli fault \(\{ (\mathrm{edge}(e), t, X)\} \);

• and analogously for all other generator types.

The product of two fault patterns \(p\) and \(q\) is their disjoint union:

A fault pattern \(p\) is generated by the listed generators if there exists a list of generators whose patterns product to \(p\):