Researchers Demonstrate Logical Qubit Operations with Low Error Rates of 0.03

A key step towards scalable quantum computation has been achieved with the experimental realisation of lattice-surgery operations between logical qubits. Yanzhe Wang and colleagues at Zhejiang University, in collaboration with Graduate School of China Academy of Engineering Physics, have successfully performed these operations on a planar superconducting processor, achieving per-cycle error rates of 0.0365 and 0.0282 for the logical qubits. The team’s deterministic preparation of a logical Bell state and execution of a two-qubit Deutsch-Jozsa algorithm at the logical level confirms the utility of this approach. Furthermore, implementation of magic-state injection and gate teleportation yielded a logical gate fidelity of 0.943 for a logical R_X(π/4) gate, establishing lattice surgery as a viable paradigm for fault-tolerant quantum computation in superconducting circuits.

High-fidelity logical qubit control and two-qubit algorithm execution via lattice surgery

A logical RX(π/4) gate fidelity of 0.943+10−9 has been achieved, a substantial improvement over the 0.930 reported in similar systems. Researchers at Zhejiang University and the Graduate School of China Academy of Engineering Physics demonstrated lattice surgery, a technique for manipulating quantum information within a surface code, between two fully error-correctable logical qubits on a superconducting processor. The team achieved this accuracy, surpassing the threshold required for practical quantum error correction, with consistent reliability.

The work validates the viability of this approach for constructing larger, more stable quantum computers, and successfully executed a two-qubit Deutsch-Jozsa algorithm at the logical level, confirming its computational utility. Measurements revealed per-cycle error rates of 0.0365 and 0.0282 for the two logical qubits during repeated syndrome extraction cycles; these measurements excluded instances of leakage events, indicating strong error mitigation. A deterministic logical Bell state, confirming genuine entanglement, was prepared using joint initialisation and lattice splitting, a key operation in manipulating quantum information. To enable universal control, magic-state injection and gate teleportation were implemented, allowing for continuous rotations around the logical X axis; this expands the range of operations possible on the qubits. Despite these promising results, performance with sharply larger qubit numbers or the complexities of scaling up to practical, error-corrected algorithms remains to be seen.

Demonstration of Fault-Tolerant Computation with Interconnected Logical Qubits

Experimental realisation of foundational lattice-surgery operations occurred between two distance-three surface-code logical qubits on a superconducting system comprising 125 qubits. This logical processor was utilised to investigate fundamental fault-tolerant quantum computation primitives and small-scale programmable logical algorithms. Specifically, a lattice-split operation deterministically prepared a Bell state across the two surface-code logical qubits, simultaneously protecting against bit-flip and phase-flip errors.

A two-qubit Deutsch-Jozsa algorithm was executed at the logical level, employing soft post-selection to enhance classification accuracy. Furthermore, a magic-state injection and gate-teleportation circuit achieved continuous non-Clifford logical rotations around the logical X axis, characterising the resulting logical RX(π/4) gate via quantum process tomography. This thorough validation of lattice surgery confirms it as a viable route toward scalable logical computation.

Quantum error correction is essential for realising large-scale quantum computation in the presence of noise. The surface code is the leading candidate among diverse quantum error correction codes due to its high fault-tolerance threshold, local stabilizer structure, and compatibility with planar qubit layouts. Recent experimental progress has enabled the demonstration of repeated syndrome extraction cycles and the realization of logical memory lifetimes that surpass the break-even point.

These advances establish encoded quantum memory as a realistic primitive, shifting the focus to the next critical challenge: implementing logical operations that preserve fault tolerance while remaining compatible with practical hardware constraints. Fault-tolerant logical operations implement the desired computation while preventing low-weight physical errors from propagating into uncorrectable logical failures. Transversal operations offer a straightforward approach to fault tolerance, but performing them between code blocks necessitates non-local connectivity, a feature of reconfigurable systems like trapped ions and Rydberg atoms.

For solid-state platforms restricted to static planar layouts, such as superconducting qubits, lattice surgery has emerged as the foundational model for logical operations. By dynamically deforming surface-code patches, it enables various operations among logical qubits under the strict constraints of two-dimensional architectures. This approach implements computation by measuring joint logical Pauli operators between adjacent logical qubits through the merging and splitting of code patches.

These two primitives serve as the building blocks for a universal gate set, including both Clifford and non-Clifford logical gates. Recent experiments have demonstrated lattice surgery for logical state teleportation between a pair of distance-three colour-code logical qubits and Bell state preparation by splitting a distance-three surface code into two repetition-code blocks. However, the direct demonstration of lattice surgery between fully error-correctable surface-code patches, as well as the realization of non-Clifford logical gates, remained an outstanding experimental challenge until now.

In this work, researchers experimentally realised these foundational lattice-surgery operations between two distance-three surface-code logical qubits. The quantum processor comprises a two-dimensional array of superconducting transmon qubits with tunable nearest-neighbour coupling. Within this array, two logical qubits, L1 and L2, each encoded in a distance-three surface code, were defined. Each logical qubit is hosted on a patch consisting of nine data qubits and eight syndrome qubits.

Syndrome qubits measure X- and Z-type stabilizers on adjacent data qubits; for instance, qubit Z1 measures the stabilizer SZ1 = ZD0ZD1ZD3ZD4. The logical space of each patch is defined by the simultaneous +1 eigenspace of all stabilizers, with the remaining degree of freedom encoding the logical information. The logical Pauli operators for L1 are XL1 = XD6XD7XD8 and ZL1 = ZD0ZD3ZD6; for L2, the operators are XL2 = XD12XD13XD14 and ZL2 = ZD12ZD15ZD18. Repeated syndrome extraction cycles were performed to preserve the logical information, with each cycle comprising a full round of stabilizer measurements. To implement a fault-tolerant XL1XL2 measurement, the two disjoint code patches were positioned such that their logical X operators faced each other.

Three ancilla data qubits and four ancilla syndrome qubits, all initialised in the state |0⟩, were introduced between the two patches. L1 and L2 were then merged into a single surface code by dynamically reconfiguring the syndrome extraction circuits in the subsequent syndrome extraction cycles. Specifically, the boundary Z-type stabilizer measured by Z3 was extended from ZD6ZD7 to ZD6ZD7ZD9ZD10, and Z4 was extended from ZD13ZD14 to ZD10ZD11ZD13ZD14. Simultaneously, the four ancilla syndrome qubits measured newly established X-type stabilizers that act across the boundary data qubits of L1, L2, and the ancilla data qubits.

This lattice-merge operation explicitly defines an elongated 7 × 3 rotated surface code, denoted as L3. Crucially, the operator XL1XL2 is equivalent to the product of the four newly established X-type stabilizers, Q7 j=4 SXj; thus, the measurement outcome is extracted from the parity of these syndrome records, and the joint system is projected into an eigenspace of XL1XL2. Following the merge, the original two logical qubits can be recovered by performing a split operation: the three ancilla data qubits were measured in the Z basis, the X-type stabilizer measurements associated with the four ancilla syndrome qubits were ceased, and the boundary Z-type stabilizers corresponding to Z3 and Z4 were restored from weight-four back to weight-two. As demonstrated in previous experiments, the lattice-split operation itself can be used to generate entangled states. The physical performance of the device is summarised, showing cumulative distributions of error probabilities for relevant operations.

The median gate fidelities are 0.9995 and 0.996 for single-qubit gates and two-qubit controlled-π phase gates, respectively. The median Pauli error for data qubits idling during a measurement cycle is 0. Readout assignment errors are 0.025 for two-state discrimination and 0.049 for three-state discrimination. To benchmark logical memory performance, repeated syndrome extraction cycles were conducted on the two disjoint code patches. Fitting the decay of logical fidelity to an exponential function of the cycle number yielded per-cycle logical error rates of εL1 = 0.0365 and εL2 = 0.0282. The difference between these values reflects variation in physical-qubit performance across the device.

A key practical application of lattice surgery is the deterministic generation of entanglement between logical qubits. Researchers demonstrated this using a lattice-split protocol. Initially, all data qubits were prepared in the state |0⟩. They then executed three rounds of syndrome extraction cycles, wherein syndrome qubits measured the stabilizers of the merged surface code, L3. These stabilizer measurements projected the data qubits into the logical state |0L3⟩ while providing the syndrome records necessary for fault-tolerant error decoding and correction.

Following the third syndrome extraction cycle, the merged code was split into L1 and L2 by measuring out the ancilla data qubits, and then reconfiguring the syndrome extraction circuits for two isolated code patches. To make the split operation deterministic, Pauli-frame updates were applied conditioned on the intermediate measurement outcomes. Specifically, if the measurement of stabilizers during the third syndrome extraction cycle yielded an outcome of −1 for SX4SX5, a logical Z gate was effectively applied to L1; if the measurement of ZD9 yielded −1, a logical X gate was effectively applied to L1. Accounting for these Pauli-frame updates, an X-type lattice split transforms the logical state according to α |+L3⟩+ β |−L3⟩→α |+L1+L2⟩+ β |−L1−L2⟩, where |±L⟩= (|0L⟩± |1L⟩) / √2. Given their initialisation in the state |0L3⟩, the resulting state is a logical Bell state, |Φ+ L ⟩= (|0L10L2⟩+ |1L11L2⟩) / √2. To characterise the fidelity of the generated Bell state, the expectation values of three two-qubit logical operators XL1XL2, YL1YL2, and ZL1ZL2 were measured.

Surface code manipulation shows promise despite data selection challenges

Scientists are edging closer to practical quantum computers by demonstrating reliable operations on encoded, error-protected qubits. This achievement relies on ‘lattice surgery’, a method of manipulating quantum information within a surface code, but the team’s use of post-selection, discarding data from flawed runs, suggests a fundamental tension. They cleverly mitigated this by incorporating Pauli-frame tracking, effectively absorbing corrections into the quantum operations themselves, though this approach isn’t universally applicable.

The need to discard flawed data remains a limitation for building truly scalable systems, introducing a bias. Nevertheless, this demonstration of ‘lattice surgery’ is significant because it proves these complex operations are achievable with reasonable accuracy. Incorporating corrections directly into the quantum operations, via Pauli-frame tracking, is a clever workaround, paving the way for more robust quantum processing. Researchers have demonstrated reliable quantum operations using ‘lattice surgery’ on protected quantum bits, a key step towards practical quantum computers.

Lattice surgery now stands validated as a practical method for performing computations with error-corrected quantum bits, or logical qubits. This research successfully demonstrated operations between two such qubits built using a surface code on a superconducting processor; a surface code is a specific arrangement of qubits designed to protect quantum information from noise. Achieving a logical gate fidelity of 0.943 confirms the viability of this approach, exceeding previous benchmarks and signalling a key advance in building stable quantum computers.

The researchers successfully performed logical operations on two distance-three surface-code qubits using a technique called lattice surgery. This is important because protecting quantum information from errors is essential for building useful quantum computers, and this work demonstrates a viable method for doing so. They achieved a logical gate fidelity of 0.943, and also prepared a logical Bell state confirming entanglement between the qubits. The authors state that these results represent a critical milestone towards scalable fault-tolerant quantum advantage in superconducting circuits.