Quantum error correction works by encoding a single logical qubit across multiple physical qubits, then repeatedly measuring the physical qubits to detect and fix errors. The measurements are the correction — they collapse errors into identifiable patterns that can be reversed. But computation requires performing operations on the logical qubit, and these operations must modify the encoded state. The problem: modifying the state and checking it for errors are, in the standard approach, mutually exclusive. You either protect the qubit or compute with it. You cannot do both simultaneously.
The standard workaround is to pause error correction, perform the computation, then resume correction and hope no fatal error occurred during the unprotected window. This is like taking off your parachute to adjust the straps. The computation window is a vulnerability — a period during which errors accumulate without detection. For short computations on high-quality qubits, the window is survivable. For long computations, the accumulated errors during unprotected windows dominate the error budget.
Researchers at ETH Zurich, led by Andreas Wallraff, demonstrated lattice surgery between superconducting logical qubits with continuous error correction — computation and correction running simultaneously. The technique performs logical operations by temporarily merging and splitting the lattice structures that encode the logical qubits. During the merge, both qubits share a larger error-correcting code. The operation is embedded in the code structure itself rather than applied to the bare logical state. The correction never pauses because the operation never exposes the state.
The structural insight is about whether protection and action are fundamentally incompatible. In classical computing, this question does not arise — reading a bit does not disturb it, and operations do not create random errors. In quantum computing, every operation has a probability of introducing an error, and every measurement collapses superposition. Protection (measurement-based correction) and action (state modification) seemed to compete for the same resource: the state itself. The lattice surgery approach resolves the competition by operating at a different level — modifying the code structure rather than the encoded state. The state is never unprotected because the operation happens in the code, not in the qubit.
This is analogous to performing surgery on a patient who remains connected to life support throughout the procedure. The traditional approach disconnects the patient, operates quickly, and reconnects. The new approach redesigns the surgery to work within the constraints of continuous monitoring. The patient is never off the monitor. The cost is that the surgery must be designed around the monitoring system, which constrains the types of operations available. But the benefit — no unprotected window — scales with computation length. Short computations are fine either way. Long computations are only feasible with continuous correction.
The practical implication for quantum computing is immediate: fault-tolerant quantum computation becomes possible with lower physical qubit counts and shorter total runtimes, because the error budget no longer includes contributions from unprotected computation windows. The theoretical overhead of error correction decreases when correction and computation are concurrent rather than alternating. The machine spends no time vulnerable.