Snakes and Ladders: Adapting the surface code to defects

TL;DR

A suite of novel and highly performant methods for adapting surface code patches in the presence of defective qubits and gates, which is explained and compares several strategies in order to find the optimal one for any given configuration of defective components.

Abstract

One of the critical challenges solid-state quantum processors face is the presence of fabrication imperfections and two-level systems, which render certain qubits and gates either inoperable or much noisier than tolerable by quantum error correction protocols. To address this challenge, we develop a suite of novel and highly performant methods for adapting surface code patches in the presence of defective qubits and gates, which we call \emph{Snakes and Ladders}. We explain how our algorithm generates and compares several strategies in order to find the optimal one for any given configuration of defective components, as well as introduce heuristics to improve runtime and minimize computing resources required by our algorithm. In addition to memory storage we also show how to apply our methods to lattice surgery protocols. Compared to prior works, our methods significantly improve the code distance of the adapted surface code patches for realistic defect rates, resulting in a logical performance similar to that of the defect-free patches.

Figures (24)

• Figure 1: (a) A processor consisting of a square lattice of qubits with nearest-neighbor gates. Several defective components marked in red. The question we study is how to realize the most performant surface code within a target window (yellow square) of dimensions $w\times h$. In absence of defects, this window supports a surface code with distance up to $(d_X, d_Z) = (h, w)$. In this example $w=h=7$. (b) A surface code patch with distance $(d_X, d_Z) = (3, 3)$ featuring no defective components. This is the surface code patch with the largest distance, free of defective components, that we can make in the current window. (c) A surface code patch adapted to defects using DQD. This code has distance $(d_X, d_Z) = (5, 3)$. (d) A surface code patch adapted to defects using SnL, resulting in distance $(d_X, d_Z) = (6, 6)$ which is closer to the maximum distance possible in the target window. In (b)-(d), gauge checks of the same color are combined together into super-stabilizers and are connected together with lines.
• Figure 2: Primitive operations used in our framework, for isolated defects. The highlighted checks are measured in alternating rounds, and the numbers indicate which checks are measured in odd and even rounds. The DQD strategies are shown in the left column for (a) a data defect, (b) an ancilla defect, (d) a link defect (mapped to a data defect). The SnL strategies for the same defects are shown in the right column.
• Figure 3: Applying SnL to a cluster of defects. (a) We identify ancilla and link defects and combine all possible ways of repurposing.(b) For each combination of primitive operations found in (a) we determine which repurposed checks are invalid and disable data qubits in them. This process is simplified by identifying connected components of repurposed checks. We disable all data qubits in a connected component if there is a defect anywhere in that component or if an ancilla qubit is repurposed more than once. These disabled data qubits form a "snake". (c) We apply the data defect primitive around each defective and disabled data qubit, converting stabilizers around them to gauge checks. (d) We identify the super-stabilizers based on the commutation relations. For more details, see \ref{['app:super-stabilizers']}.
• Figure 4: Application of our strategies for two examples of defect clusters: (a)-(b) adjacent ancilla and data defects, and (c)-(d) two adjacent ancilla defects. (b) and (d) show the best two strategies that we find for each defect configuration with SnL.
• Figure 5: Routine for the boundary deformation. (a) We find all strategies for the defect cluster. We only show the top left corner of the target window (in yellow) for compactness. b) For each strategy, we determine if the gauge checks require qubits outside of the target window (highlighted in yellow). (c) For each strategy, we determine if one or more corners are part of the gauge checks or disabled. Here we show (using the yellow star) two possible corner placements for the strategy in (b). (d) If a corner is compromised, we repeat this step for every possible corner placement found in (c), otherwise we only do this step once. We remove all gauge checks that fall outside the target window. For each remaining gauge check we determine if it can 1) be converted to a valid boundary check or 2) be part of a smaller super-stabilizer within the target window such that the commutation relations are satisfied. If not, then we eliminate the check. For example, the two red gauge checks in (c.1) became gray boundary checks in (d.1). On the other hand, the red gauge checks in (d.2) form a new super-stabilizer in the bulk.