Macromux: scalable postselection for high-threshold fault-tolerant quantum computation

Abstract

We introduce a new resource-efficient scheme for fault-tolerant quantum computation known as `macroscale multiplexing' (or simply `Macromux'), that utilizes scalable postselection to significantly improve the threshold of a given fault-tolerant protocol against both Pauli and erasure errors. Macromux is a hierarchical method for postselecting on constant-size space-time windows of a fault tolerant protocol, requiring only constant additional overheads. The method can be straightforwardly implemented for any fault-tolerant protocol and in any architecture that has access to routing and memory, such as linear-optical fusion-based architectures. We construct fault-tolerant protocols that, to our knowledge, have the highest thresholds in the literature; we perform simulations of fusion-based schemes based on the surface code, showing a maximum possible increase in Pauli thresholds of up to a factor of $\sim6$ (from $1.0\%$ to $5.9\%$). Our schemes are highly-resource efficient, and can for example, double the loss thresholds of some photonic fusion-based protocols using as little as $3 \times$ overhead.

Figures (13)

• Figure 1: The idea behind Macromux. A fault-tolerant computation consists of a series of operations on a set of qubits in space-time. In fusion-based quantum computation, these blue nodes correspond to small entangled states called resource states and black edges are fusions (Bell-basis measurements). (top row) Standard fault-tolerant constructions perform operations layer-by-layer, at times $t_1$, $t_2$, $t_3$, consistent with the flow of logical information e.g. following a quantum circuit. (middle row) For stabilizer-based fault-tolerance, we can modify the order of instructions; instead of performing operations layer by layer, we may perform them in parallel in disjoint space-time "bricks". For fusion-based quantum computation, each brick consists of a constant number of resource states and fusions. (bottom row) By partitioning the fault-tolerant computation into bricks of constant size, one may create multiple copies of each brick in parallel. Bricks can be grouped together to form larger bricks (e.g., to go from $t_1$ to $t_2$), in a way that favourably shapes the error configuration. By repeating this process up to some scale and keeping only the highest-quality bricks at the final stage, the computation can be performed with lower logical error rates.
• Figure 2: Fusion-based quantum computation with surface-code resource states. (This example is equivalent to the 6-ring fusion network of bartolucci2023fusion up to Hadamards.) (a) shows a six-qubit resource state where each vertex is a qubit (one of the qubits is at the back of the octahedron). Each blue face represents an $X$ stabilizer and each white face represents a $Z$ stabilizer, and faces sharing an edge always have the opposite colour. Topologically this is a sphere. The stabilizer resource state group $\mathcal{R}$ and the fusion measurement group $\mathcal{F}$ are both also shown. (b) illustrates how a fusion between two qubits of two resource states creates a bigger surface-code resource state. This can be understood by noting how measuring, e.g., the $ZZ$ operator merges $Z$-type stabilizers on the two resource states. The qubits that are measured are now in a product state with the rest of the qubits and may be discarded (in linear-optical fusion-based quantum computation, the qubits would actually be destructively measured). (c) continues the process, illustrating how fusing qubits from eight resource states arranged as shown creates a bigger surface-code state. This sequence of fusions generates a check operator, given by the product of the $ZZ$ measurement outcomes, with an example shown in (d). In (e), we see the result of fusing many such resource states in this way: we get alternating $XX$ and $ZZ$ checks. (Each check only overlaps on a single fusion measurement outcome, so the decoding problem is two syndrome graph decoding problems.) By fusing qubits on pairs of opposite faces, we get periodic boundary conditions. So if we fuse qubits on the two faces perpendicular to the x direction and do the same for the z direction, we get two toric codes on the faces perpendicular to the y direction. One can show that these two toric codes are entangled giving us two logical Bell pairs. (An alternative is to create two entangled planar codes by doing single-qubit measurements of the qubits on the x and z planes.)
• Figure 3: (Toy 2D example of a fusion network, diced into four stages. (top left) The fusion network: resource states are 4 qubit rings, and fusions are $\{XX,ZZ\}$ Bell measurements. Boundary conditions not shown (assume periodic, for example). (top right) The initial stage has bricks that are single resource states, and there are $M=2$ copies of each brick. (bottom left) The second stage has bricks that are pairs of resource states fused together, and there are $M=2$ copies of each brick. (bottom right) The third stage has bricks that are pairs of stage-2 bricks, and there are $M=2$ copies of each brick. The final stage fuses all bricks together to give the original fusion network.
• Figure 4: (a) Schematic of how 1x1 bricks are ranked and fused together to create 2x1 bricks in the 2D example. Here we have the possibility of imperfect resource states: the complete four-qubit ring state is the ideal, whereas other states with, e.g., cut edges or missing nodes are imperfect. Note that the routing schematic is for illustrative purposes only, with more efficient approaches possible bartolucci2021switch.
• Figure 5: Example computing the frozen gap on a 2D surface code syndrome graph with partially checked outcomes around the boundary. Nodes are syndrome locations and edges are error locations. We consider the top and bottom rough edges to be the gap boundary, while the left and right are freezing boundaries. We first perform a matching to potentially freeze out some syndromes, in this case the freezing weight is $w=2$. Then the logical gap is computed as $\Delta = |1-5| = 4$. The frozen gap is $\Delta_f = \max(4-2\phi, 0)$.