Decoding across transversal Clifford gates in the surface code

TL;DR

This work addresses decoding for fast, transversal Clifford gates in the surface code, where standard MWPM must handle time-like hyperedges that arise when gates map stabilizers to products. The authors introduce the logical observable matching (lom) decoder, which applies minimum-weight matching to subgraphs aligned with the backpropagated logical observables, enabling fault-tolerant decoding with a basic error model and outperforming hypergraph-splitting methods. To achieve scalability, they develop windowed-lom variants (basic and two-step) that partition the circuit in time and use multiple independent single-lom decodings to manage open time-boundaries and fast resets; both variants face trade-offs between efficiency and fault-tolerance, mitigated by synchronization and short-cut edges. Numerical simulations across memory-equivalent and multi-qubit Clifford circuits show strong performance under phenomenological and circuit-level noise, with lom preserving circuit-distance and demonstrating robust thresholds, while revealing challenges such as time-like snakes that the proposed windowed decoders aim to address. The results indicate that efficient, fault-tolerant decoding of fast logical gates in the surface code is feasible and point to concrete avenues for real-time decoding and further threshold analyses.

Abstract

Transversal logical gates offer the opportunity for fast and low-noise logic, particularly when interspersed by a single round of parity check measurements of the underlying code. Using such circuits for the surface code requires decoding across logical gates, complicating the decoding task. We show how one can decode across an arbitrary sequence of transversal gates for the unrotated surface code, using a fast "logical observable" minimum-weight-perfect-matching (MWPM) based decoder, and benchmark its performance in Clifford circuits under circuit-level noise. We propose windowed logical observable matching decoders to address the problem of fully efficient decoding: our basic windowed decoder is computationally efficient under the restriction of quiescent (slow) resets. Our 'advanced' two-step windowed decoder can be computationally inefficient but allows fast resets. For both windowed decoders we identify errors which scale sublinearly in $d$ - depending on the structure of the circuit - which can lead to logical failure, and we propose methods to adapt the decoding to remove such failures. Our work highlights the complexity and interest in efficient decoding of fast logic for the surface code.

Figures (31)

• Figure 1: (a) The $d=3$ unrotated surface with data qubits as white circles and $X$- (resp. $Z$-) stabilizers as shaded red (resp. blue) regions. Representatives of the Pauli $\overline{X}$ (reps. $\overline{Z}$) are shown by the red (resp. blue) circles around the data qubits on which it has support. (b, c) The fold-transversal $\overline{H}$ and $\overline{S}$ gates, respectively. The logical Hadamard gate is implemented as a layer of Hadamard gates followed by a layer of SWAP gates. The long-range SWAPs (resp. CZs) are shown as thick black (resp. yellow) lines.
• Figure 2: Decoding hypergraphs $\mathcal{G}$ when executing a logical operation assuming a basic error model, using the pre-gate frame. Time flows from left to right and the vertical gray dashed lines denote half-integer layers when a logical gate followed by a QEC round happens, so that detectors are labeled by integer times $t\in \mathbb{Z}$. In the subfigures, the logical gate+QEC round happens at layer $t+1/2$ while for all other layers we perform the identity gate. Logical reset and measurement happen at $t+1/2$ and are only shown for $\overline{Z}$, as the decoding hypergraphs for the $\overline{X}$-basis are the same but with the $X$ and $Z$ detector types swapped. The decoding hypergraphs are three-dimensional for the surface code, but we have drawn a two-dimensional slice for easier visualization. Note that for the logical $\ket{\overline{0}}$ there are no weight-1 time-like edges---the time-boundary is closed---while for the $X$-detectors there are weight-one time-like edges---the time-boundary is open.
• Figure 3: Hyperedge decomposition and error combination that explains the bad performance of a "splitting-hyperedge" matching decoder in the pre-gate frame. (a) $\mathcal{G}_{\text{matchable}}$ of the $\overline{S}$ gate, which is built by only taking the edges from the decoding hypergraph in Fig. \ref{['fig:hyperedges']}. (b) The procedure from Ref. delfosse2023 to decompose the gray hyperedge goes as follows: (1) the detectors involved in the hyperedge are triggered (yellow dots), (2) such syndrome is decoded with mwpm using $\mathcal{G}_{\text{matchable}}$, and (3) the correction (purple edges) corresponds to the hyperedge decomposition. Note that the number of purple edges in the decomposition can badly grow with the code distance. (c) The two errors marked in red lead to a logical error when decoded using $\mathcal{G}_{\text{matchable}}$, thus the logical scaling is at most $O(p^2)$ for any distance.
• Figure 4: The decoding hypergraph and subgraph $G_O$ for an observable $O$ for an example circuit . (a) The observing region $O^{\leftarrow}$ of the observable $O$ being the $Z$-measurement is shown, where red, green and blue shading indicates $X$, $Y$ and $Z$ support respectively. (b) The decoding hypergraph $\mathcal{G}$ of the encoded circuit $\overline{\mathcal{C}}$ for the $d=3$ unrotated surface code. The vertices of $\mathcal{G}$ are partitioned based on the logical qubit to which they pertain and whether they represent $X$- (red background) or $Z$- (blue background) detectors. Note that the $x$ and $y$ spatial coordinates have been swapped between the $X$- and $Z$-detectors for ease of visualization. Also note that we have only shown the weight-3 hyperedges that appear on the top-front qubit to reduce clutter; weight-3 hyperedges with the same pattern also exist at all the other spatial coordinates in $\mathcal{G}$ but are not shown here. We have also labeled all the edges that make up the observing edge set $\mathcal{H}_{O}$ (in blue and red), and the open and closed time boundaries that arise from resets and measurements in (a). (c) The decoding subgraph $G_{O}$ for the observable $O$. As explained in the text, $G_{O}$ contains all the vertices $V_{O}$ of $\mathcal{G}$ that pertain to the same logical qubit and represent a detector of the same Pauli type ($X$ or $Z$) as an edge in the observing edge set. It clearly has the property that it is a graph with no hyperedges. Vertices that are excluded from $V_{O}$ are shaded in gray.
• Figure 5: An example of a weight-5 error in the $d=7$ surface code in which the decoded outcomes for the reliable observables $O_{1}$, $O_{2}$ and $O_{3}=O_{1}O_{2}$ are inconsistent. (a) The circuit consists of two consecutive CNOT gates, with both qubits initialized and measured in the $Z$-basis. The logical action of the circuit is trivial here and only serves as a simple example. (b) The observing regions of the three observables. (c) The $Z$-detectors in the decoding hypergraph $\mathcal{G}$. For simplicity, only a slice of $\mathcal{G}$ is shown for a fixed value of the spatial coordinate $x$. When each of the observables is decoded by the single-lom decoder, it predicts a flip in the observable $O_{1}$ but not in $O_{2}$ or $O_{3}$, despite the fact that $O_{3}=O_{1}O_{2}$. This is only possible because the weight of the error---five---is greater than $d/2=7/2$. Note that in this figure and throughout, we will refer to measurement errors of $Z$-stabilizers as $X$-errors (and vice versa for $X$-stabilizer errors) for simplicity.

Theorems & Definitions (12)

• Lemma 1
• Definition 1: Fragile observable
• Theorem 1: Fault-tolerance of single-lom
• proof
• Definition 2: Hierarchical Tracks
• Lemma 2
• proof
• Definition 3: Short-cut edges
• Conjecture 1
• Lemma 3