A superconducting surface-code processor with lattice-surgery logical operations

This paper reports the experimental realization of fault-tolerant lattice-surgery operations on a superconducting surface-code processor, demonstrating high-fidelity logical Bell state preparation, a logical Deutsch-Jozsa algorithm, and non-Clifford gate teleportation to establish a versatile paradigm for scalable quantum computation.

The Gist

Imagine you are trying to send a fragile message across a stormy ocean. If you send a single paper boat, a single wave will sink it. But if you build a massive, reinforced raft made of many smaller boats tied together, the raft can survive the waves even if a few individual boats get damaged. This is the basic idea behind Quantum Error Correction: using many physical "boats" (qubits) to protect a single piece of information (a logical qubit).

This paper describes a major step forward in building that raft, specifically using a design called the Surface Code on a superconducting computer chip. Here is what the researchers achieved, explained simply:

1. The Setup: Building the Raft

The team built a grid of 125 tiny superconducting "boats" (qubits) on a chip. They organized these into two separate "rafts" (logical qubits), each made of 17 physical boats.

• The Challenge: In the real world, these boats are shaky. They drift, they leak energy, and they make mistakes.
• The Solution: They constantly checked the "weather" (measuring error syndromes) to see if any boats were drifting. If a boat started to drift, they could correct it before the whole raft sank. They proved that their raft could survive many rounds of these checks, with a very low chance of the whole message getting corrupted.

2. The Magic Trick: Merging and Splitting Rafts (Lattice Surgery)

The most exciting part of the paper is a technique called Lattice Surgery. Think of this as a way to perform math on two separate rafts without ever physically moving the boats around.

• Merging: Imagine you have two separate rafts floating side-by-side. To do a calculation, you temporarily tie them together into one giant, elongated raft.
• The Measurement: While they are tied together, you measure a specific property of the combined raft. This tells you something about the relationship between the two original rafts.
• Splitting: You then untie them, separating them back into two distinct rafts.

Because of how quantum mechanics works, this process of tying and untying doesn't just measure them; it entangles them. It's like taking two separate magic wands, touching them together, and then pulling them apart so that they are now magically linked: if you wiggle one, the other wiggles instantly, no matter how far apart they are.

3. What They Actually Did

The researchers used this "tying and untying" method to do three specific things:

• Creating a "Quantum Twin" (Bell State): They started with two separate logical rafts, merged them, and split them back apart. The result was two logical qubits that were perfectly linked (entangled). They proved this link was real and strong, even with the noise in the system.
• Running a Logic Puzzle (Deutsch-Jozsa Algorithm): They used their linked rafts to solve a specific logic puzzle. In this puzzle, you have to figure out if a hidden machine always gives the same answer or if it gives a mix of answers. Their quantum raft solved this correctly much more often than a "raw" (uncorrected) system could, showing that the error correction actually helped the computer think better.
• The "Impossible" Turn (Non-Clifford Gates): Standard quantum computers can easily do some turns (rotations), but they struggle with a specific type of turn called a "non-Clifford" rotation. To do this, the team used a special trick:
  1. They prepared a special "magic ingredient" (a magic state) on one raft.
  2. They merged the rafts to transfer this magic to the other raft.
  3. They split them, effectively performing a complex turn that is usually very hard to do.
     They showed they could do this with high accuracy (about 94% fidelity) when they filtered out the runs where errors were detected.

4. The Bottom Line

The paper claims that Lattice Surgery is a practical, working method for doing complex calculations on a quantum computer.

• They didn't just build a memory stick that holds data; they built a processor that can do math on that data.
• They proved that by merging and splitting these logical "rafts," they can create entanglement, run algorithms, and perform complex rotations.
• While the system still needs to be larger and more perfect to solve real-world problems, this experiment proves the fundamental building blocks for a scalable, fault-tolerant quantum computer are working as intended.

In short, they successfully demonstrated that you can take two separate, error-corrected quantum "rafts," tie them together to perform a calculation, and pull them apart to get a useful, entangled result. This is a critical milestone on the road to building a quantum computer that can actually solve problems.

Technical Summary

Technical Summary: A Superconducting Surface-Code Processor with Lattice-Surgery Logical Operations

Problem Statement
Scalable quantum computation requires fault-tolerant logical operations that prevent low-weight physical errors from propagating into uncorrectable logical failures. While the surface code is a leading candidate for quantum error correction (QEC) due to its high threshold and compatibility with planar layouts, experimental progress has largely focused on demonstrating repeated syndrome extraction cycles (SECs) and logical memory lifetimes exceeding the break-even point. The critical remaining challenge is implementing logical operations that preserve fault tolerance within the strict constraints of static, two-dimensional superconducting architectures. While transversal operations offer fault tolerance, they require non-local connectivity unavailable in planar systems. Lattice surgery, which dynamically deforms code patches to perform operations, is the proposed solution for such platforms, yet its direct demonstration between fully error-correctable surface-code patches and the realization of non-Clifford logical gates remain outstanding experimental challenges.

Methodology
The authors experimentally realized foundational lattice-surgery operations on a planar superconducting processor comprising 125 tunable transmon qubits. The system hosts two logical qubits, $L_1$ and $L_2$, each encoded in a distance-three rotated surface code (9 data qubits and 8 syndrome qubits per patch).

The core methodology involves:

1. Lattice Merge and Split: To perform joint logical operations, the two disjoint code patches are merged into a single elongated $7 \times 3$ rotated surface code ($L_3$) by dynamically reconfiguring syndrome extraction circuits. This involves extending boundary stabilizers and introducing ancilla data and syndrome qubits. The logical Pauli operators are measured via the parity of syndrome records. The patches are subsequently split back into $L_1$ and $L_2$ by measuring ancilla data qubits in the $Z$ basis and restoring original stabilizer weights.
2. State Preparation and Correction: Logical Bell states are generated deterministically via a lattice-split protocol, utilizing Pauli-frame updates conditioned on intermediate measurement outcomes to correct for measurement-induced errors.
3. Algorithmic Execution: A two-qubit Deutsch-Jozsa algorithm is executed at the logical level. The quantum oracle is implemented via lattice surgery, distinguishing constant from balanced Boolean functions.
4. Non-Clifford Operations: Universal control is achieved through magic-state injection and gate teleportation. A high-fidelity magic state is prepared on $L_2$ and consumed to perform arbitrary logical $R_X(\theta)$ rotations on $L_1$ via a joint $M_{XX}$ measurement (realized through merge/split operations).
5. Error Handling: The study employs a belief-matching decoder for error correction and utilizes "detected-error-free" post-selection (discarding runs with non-trivial syndromes or leakage events) to benchmark upper-bound performance.

Key Contributions

• Experimental Realization of Lattice Surgery: The first direct demonstration of lattice-merge and lattice-split operations between two distance-three surface-code logical qubits on a superconducting processor.
• Logical Entanglement: Deterministic preparation of a logical Bell state ($|\Phi^+\rangle_L$) across the two surface-code patches, providing simultaneous protection against bit-flip and phase-flip errors.
• Logical Algorithm Execution: Successful implementation of the Deutsch-Jozsa algorithm at the logical level, demonstrating algorithmic utility within a fault-tolerant framework.
• Non-Clifford Gate Implementation: Realization of continuous non-Clifford logical rotations around the logical $X$ axis via magic-state injection and gate teleportation, a necessary component for universal quantum computation.

Results

• Logical Memory Performance: After rejecting leakage events, the logical qubits exhibited per-cycle error rates of $\epsilon_{L1} = 0.0365(2)$ and $\epsilon_{L2} = 0.0282(1)$.
• Bell State Fidelity: The raw state fidelity was $0.372$. Using a belief-matching decoder, the fidelity lower bound improved to $F_{dec} = 0.532$, confirming genuine bipartite entanglement. Under detected-error-free post-selection, the fidelity reached $F_{pst} = 0.925$.
• Deutsch-Jozsa Accuracy: Error correction significantly improved classification accuracy. For constant functions, accuracy rose from $0.886$ (raw) to $0.970$ (decoded). For balanced functions, it improved from $0.623$ to $0.716$. Post-selection further increased these to near-unity values, though at the cost of retaining only $0.06\%$ of data for the balanced case.
• Non-Clifford Gate Fidelity: For the logical $R_X(\pi/4)$ gate, the error-corrected results showed modest improvement over raw data. Under detected-error-free post-selection, the logical gate fidelity reached $0.943^{+10}_{-9}$.

Significance
The authors claim these results establish lattice surgery as a practical and versatile paradigm for logical computation in near-term surface-code architectures. By demonstrating the full stack of operations—from memory preservation and entanglement generation to algorithmic execution and universal gate implementation—the work represents a critical milestone toward scalable fault-tolerant quantum advantage in superconducting circuits. The paper positions these findings as the essential building blocks required for transitioning from isolated quantum memories to programmable fault-tolerant processors.