Error correction itself would corrupt the computation
At the intersection of physics and engineering, a team from Zhejiang University and the China Academy of Engineering Physics has demonstrated that quantum information can be manipulated with enough precision to survive its own correction — a milestone humanity has long theorized but rarely touched. By performing lattice-surgery operations on logical qubits encoded in a 125-qubit superconducting processor, the researchers achieved a gate fidelity of 94.3%, crossing a threshold that separates promising experiment from credible path. The significance is not merely technical: it suggests that the long-promised era of fault-tolerant quantum computation is not a horizon that recedes as we approach it, but one we are genuinely closing in on.
- Quantum computers have long been undermined by their own sensitivity — every operation risks destroying the information it is meant to process, and this team set out to prove that protection and computation can coexist.
- Using a 125-qubit superconducting chip, researchers encoded two logical qubits in surface codes and performed lattice surgery — dynamically merging and splitting code patches — to execute real quantum operations without collapsing the fragile states within.
- The achieved fidelity of 94.3% on a logical gate surpasses the previous benchmark of 93%, and per-cycle error rates below 0.037 suggest the architecture could survive the demands of scaling.
- The experiment's reliance on post-selection — discarding runs where errors were detected — means the results reflect best-case performance, and building a system that handles errors without discarding data remains the field's most pressing open problem.
- The immediate trajectory points toward larger qubit arrays and practical error-corrected algorithms: the technique has been validated, but the real test is whether it holds as complexity grows.
A research team from Zhejiang University and the Graduate School of China Academy of Engineering Physics has demonstrated something the quantum computing field has long needed: reliable operations on error-corrected qubits, performed with enough precision to matter.
The experiment centered on lattice surgery, a technique in which quantum information is encoded across a grid of qubits — a surface code — and computations are performed by dynamically merging and splitting those grids. The appeal is that the information stays protected from noise even as it is being manipulated. The team implemented this on a 125-qubit superconducting processor, defining two logical qubits each built from nine data qubits and eight syndrome qubits that continuously monitor for errors.
With those protected qubits in hand, the researchers performed genuine quantum operations: creating an entangled Bell state between the two logical qubits, running a two-qubit Deutsch-Jozsa algorithm, and using magic-state injection and gate teleportation to extend the range of possible computations. The headline result was a logical gate fidelity of 94.3% — the first time such precision has been achieved at the logical qubit level, surpassing a 93% threshold set by prior work.
The approach leaned on post-selection, meaning runs where errors were detected were discarded, and on Pauli-frame tracking, which folds error corrections directly into subsequent operations. These are practical tools, but they also mean the reported numbers reflect successful runs rather than all runs — a limitation any truly scalable system will eventually need to overcome.
What the experiment establishes, clearly, is that lattice surgery works as a paradigm for fault-tolerant quantum computation in superconducting hardware. The fidelities are high enough to be meaningful. What comes next — scaling to larger qubit counts, executing algorithms that solve real problems — is where the deeper proof will be demanded.
A team at Zhejiang University and the Graduate School of China Academy of Engineering Physics has cleared a significant hurdle on the path to practical quantum computers: they've demonstrated that you can perform reliable operations on error-corrected quantum bits, and do it with enough precision to matter.
The breakthrough centers on a technique called lattice surgery, which works like this: imagine quantum information encoded across a grid of qubits, arranged in what's called a surface code. To perform operations between two of these encoded qubits—what researchers call logical qubits—you can dynamically reshape the grid itself, merging and splitting code patches to execute the computation you want. It sounds abstract, but the payoff is concrete: you can manipulate quantum information while keeping it protected from the noise that normally destroys quantum states.
The researchers built their experiment on a superconducting processor containing 125 qubits. Within this array, they defined two logical qubits, each encoded in what's known as a distance-three surface code—a specific arrangement of nine data qubits and eight syndrome qubits per logical qubit. The syndrome qubits act as sentries, continuously measuring whether errors have crept in. When the team performed repeated cycles of these measurements on their two isolated code patches, they found per-cycle error rates of 0.0365 and 0.0282—low enough to suggest the system could, in principle, be scaled up.
Then came the harder part: actually doing something with these protected qubits. The team used lattice surgery to merge their two logical qubits into a single, larger code patch, then split them apart again. In doing so, they created a logical Bell state—a quantum state in which the two qubits are entangled, a property essential for quantum computation. They also executed a two-qubit Deutsch-Jozsa algorithm at the logical level, a small but genuine quantum algorithm, and implemented magic-state injection and gate teleportation to enable continuous rotations around the logical X axis. These operations expanded the range of computations possible on the qubits beyond the basic set.
The headline number: a logical RX(π/4) gate—a specific quantum operation—achieved 94.3% fidelity. That means the operation succeeded as intended 94.3% of the time, conditioned on undetected errors. This surpasses the 93% threshold previously reported in similar systems and marks the first time such precision has been achieved at the logical qubit level. For context, previous approaches to error correction struggled to maintain information integrity during computation itself; the operation would degrade the very thing it was meant to protect. This work shows that's no longer inevitable.
The team's approach relied on post-selection—discarding data from runs where errors were detected—and on Pauli-frame tracking, a clever method of absorbing corrections directly into the quantum operations themselves rather than applying them separately. This sidesteps some practical complications, though it introduces a subtle bias: you're only counting the successful runs. For a truly scalable system, you'd need to handle errors without throwing away data. That remains an open problem.
What matters now is that lattice surgery has been validated as a viable paradigm for fault-tolerant quantum computation in superconducting circuits. The technique works. The fidelities are high enough. The next frontier is scaling: demonstrating these operations on larger numbers of qubits and executing practical, error-corrected algorithms that actually solve problems. That's where the real test begins.
Notable Quotes
These results represent a critical milestone towards scalable fault-tolerant quantum advantage in superconducting circuits— Research team, Zhejiang University and Graduate School of China Academy of Engineering Physics
The Hearth Conversation Another angle on the story
Why does 94.3% fidelity matter? Isn't that just one number?
It matters because it's the first time anyone has done a logical gate—a quantum operation on error-corrected qubits—with that level of precision. Before this, error correction itself would corrupt the computation. You'd protect the information, then lose it the moment you tried to use it.
So the error correction doesn't slow you down?
Not in the way you'd think. The surface code is always running, always measuring. The real question is whether you can perform operations without those operations introducing more errors than the code can fix. This work shows you can, at least for the operations they tested.
What's lattice surgery actually doing?
It's reshaping the grid of qubits on the fly. You merge two separate error-corrected regions into one, perform a measurement that entangles the logical qubits, then split them apart again. It's elegant because it works within the constraints of superconducting qubits—you can't move them around, so you move the code structure instead.
They used post-selection. Doesn't that mean they threw away the bad runs?
Yes. They discarded data where errors were detected. That's a limitation for scaling—you can't throw away half your data in a real quantum computer. But they used Pauli-frame tracking to work around it, essentially absorbing the corrections into the operations themselves. It's a workaround, not a solution, but it shows the path forward.
What happens next?
They need to do this with more qubits and more complex algorithms. Two logical qubits is a proof of concept. A useful quantum computer will need hundreds or thousands. And they need to handle errors without discarding data. That's the real scaling challenge.