⚛️ quantum physics

Protecting bosonic codes from ancilla-induced errors with continuous-variable flags

This paper introduces a "continuous-variable flag" scheme that utilizes an auxiliary oscillator to detect and correct ancilla-induced continuous errors in bosonic quantum error correction, thereby significantly extending logical lifetimes without requiring new hardware components.

Original authors: Thomas Décultot, Ronan Gautier, Mazyar Mirrahimi

Published 2026-10-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Thomas Décultot, Ronan Gautier, Mazyar Mirrahimi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Quantum computers promise to solve problems that are currently impossible for classical machines, from designing new medicines to cracking complex codes. To work, these machines rely on delicate units of information called qubits, which can exist in multiple states at once. However, qubits are notoriously fragile; the slightest disturbance from their environment can corrupt the information they hold, causing the computer to fail. To combat this, scientists have developed quantum error correction, a method where information is spread out across many physical components so that if one fails, the whole system can recover. A particularly promising approach uses "bosonic codes," which store data not in a single particle, but in the vibrations of a tiny, invisible drum-like object called a harmonic oscillator. These oscillators can hold a vast amount of information in a single device, potentially reducing the massive hardware overhead usually required for quantum computing.

Yet, controlling these oscillators presents its own set of challenges. In many leading quantum platforms, such as superconducting circuits, the oscillator is manipulated by a helper particle, often a simple two-level atom known as an ancilla qubit. This helper acts as a switch, telling the oscillator when to rotate or shift its state. The problem is that this helper is also fragile. If the helper particle decays or loses energy at the wrong moment during a command, it doesn't just stop working; it leaves a messy, continuous trail of errors on the oscillator. These errors are not simple, discrete mistakes that standard correction codes can easily fix. Instead, they are like a continuous smear of distortion that can push the stored information into a state that is impossible to recover, effectively breaking the computer's ability to protect its data.

In a new study, researchers have introduced a clever solution to this specific problem: a "continuous-variable flag." Imagine the helper particle is connected not just to the memory oscillator, but also to a second, auxiliary oscillator that acts as a witness. This witness, or flag, is designed to record exactly what happens if the helper particle fails. When the helper particle decays, the flag doesn't just signal that an error occurred; it captures the precise nature of that error in its own physical state. By measuring this flag with high precision, scientists can determine exactly how the memory was corrupted and apply a specific correction to undo the damage. The result is that a continuous, uncorrectable smear of error is transformed into a discrete, manageable mistake that the quantum code can handle.

The researchers demonstrated that this method works for the two most common operations used to control these quantum memories: conditional rotations and conditional displacements. In a conditional rotation, the memory spins based on the state of the helper; in a conditional displacement, the memory shifts its position. Without the flag, a decay of the helper during these operations leaves the memory in a random, corrupted state. With the flag, the system can detect the exact moment the helper failed. For the rotation operation, a single flag is sufficient to protect the system against errors of any size, effectively neutralizing the helper's decay entirely. For the more complex displacement operation, a single flag can correct the most common, single-decay errors, while adding a second flag allows the system to correct even the rare, double-decay events.

The team tested these ideas through detailed computer simulations using realistic parameters for superconducting circuits. They applied the method to two different types of quantum error-correcting codes: a four-component cat code and a finite-energy grid code. In the simulations for the cat code, the flag reduced the rate of logical errors by more than a thousand times compared to systems without the flag. For the grid code, the method pushed the lifetime of the stored information very close to the theoretical limit where the helper particle is perfect and never decays. These results suggest that the continuous-variable flag is a powerful tool for making quantum computers more reliable. It turns a fundamental weakness—the inevitable decay of the control particle—into a detectable event that can be fixed, bringing fault-tolerant quantum computing a significant step closer to reality.

The researchers also examined whether real-world imperfections would ruin the system. They found that the method is robust against several common issues, such as imperfect measurement tools or the natural loss of energy from the flag itself. While these flaws do introduce some noise, they do not prevent the system from working; they simply require slightly larger signals or minor adjustments to the protocol. The study concludes that this approach does not require exotic new hardware, as the flag can be driven by the same control signals used for the main operations. By turning a continuous, unfixable error into a discrete, correctable one, the continuous-variable flag offers a practical path forward for building quantum computers that can operate reliably in the noisy real world.

Technical Summary: Protecting Bosonic Codes from Ancilla-Induced Errors with Continuous-Variable Flags

Problem Statement
Bosonic quantum error correction (QEC) offers a hardware-efficient path to fault tolerance by encoding logical qubits in the infinite-dimensional Hilbert space of harmonic oscillators (e.g., superconducting cavities). However, the control of these oscillators typically relies on an ancillary qubit (such as a transmon) coupled via dispersive interaction. A critical limitation in current architectures is that spontaneous decay of the ancilla during gate operations propagates to the oscillator as a continuous error.

Specifically, for conditional rotation ( $CR$ ) and conditional displacement ( $CD$ ) gates, the magnitude of the error induced on the memory depends on the precise time $\tau$ at which the ancilla decays. This results in a continuous error channel where the memory undergoes random rotations or displacements distributed over a wide interval. These errors often exceed the correction capability of rotation-symmetric codes (like cat codes) or translation-symmetric codes (like GKP codes), as the error magnitude is not discrete and cannot be simply identified by standard syndrome measurements. Existing mitigation strategies, such as engineering longer-lived ancillas or using higher-order couplings, are limited by scalability or only correct errors to first order.

Methodology: The Continuous-Variable Flag
The authors propose a novel protocol called the continuous-variable flag. Instead of attempting to prevent the error, this method makes the continuous error detectable and correctable by correlating it with an auxiliary oscillator mode (the flag).

Architecture: The system consists of a memory mode, an ancillary qubit, and a flag mode. Both the memory and the flag are dispersively coupled to the ancilla.
Encoding Mechanism: During the execution of a gate (e.g., $CR(\theta)$ $C R (θ)$ or $CD(\beta)$ $C D (β)$ ), the flag is driven such that its phase-space position evolves conditionally on the ancilla state.
- In the absence of decay, the flag components corresponding to the ancilla's ground ( $|g\rangle$ ) and excited ( $|e\rangle$ ) states follow distinct trajectories that recombine at the end of the gate, returning the flag to the vacuum state $|0\rangle$ .
- If the ancilla decays at time $\tau$ , the trajectory is interrupted. The flag fails to return to vacuum and instead ends in a coherent state $|z(\tau)\rangle$ , where the complex amplitude $z(\tau)$ encodes the time of the jump.
Discretization via Feedback: After the gate, a heterodyne measurement of the flag yields an outcome $\gamma$ . This outcome provides an estimate of the jump time $\tau$ and, consequently, the specific continuous error (rotation angle or displacement) inflicted on the memory. A conditional feedback operation (rotation or displacement) is then applied to the memory to undo the error, up to a stabilizer of the bosonic code.
Discretization Effect: This process transforms the continuous error channel into a discrete one. The residual errors are concentrated around values that correspond to the identity or code stabilizers (e.g., $R(-2\theta)$ for cat codes or $D(-2\beta)$ for GKP codes), rendering them harmless.

Key Contributions and Protocols

Conditional Rotation ( $CR$ ):
- The authors construct a flagging sequence using a single flag mode.
- Under a " $\chi$ -matching" condition (where the dispersive coupling ratio satisfies $\chi_f = \pi \chi_m / \theta$ ), the protocol protects the gate against ancilla decay to all orders.
- Even without strict $\chi$ -matching, the protocol can be adapted with intermediate displacements to maintain protection, provided the mapping between jump time and flag position remains injective.
Conditional Displacement ( $CD$ ):
- The $CD$ gate is typically implemented via an Echoed Conditional Displacement (ECD) sequence involving two conditional rotations separated by a qubit echo ( $\sigma_x$ ).
- One-Flag Protocol: A single flag can protect the gate against first-order decay events (single jumps). However, it fails to distinguish between different double-jump trajectories (one before and one after the echo) that result in the same flag position but different memory displacements.
- Two-Flag Protocol: By introducing a second flag mode that monitors the second conditional rotation, the authors achieve protection to all orders. The combined state of the two flags uniquely determines the memory displacement for any sequence of jumps.

Results and Benchmarks
The authors benchmarked these protocols using realistic circuit-QED parameters:

Four-Component Cat Code (Parity Measurement):
- Applied to the parity measurement of a four-component cat code.
- Simulations show that the flagging protocol reduces the logical bit-flip probability by more than three orders of magnitude compared to the unflagged case.
- For a flag mean photon number of $|\zeta|^2 = 100$ , the logical error rate drops from $\approx 2.5 \times 10^{-3}$ to $\approx 5 \times 10^{-7}$ .
- This improvement comes at the cost of increased syndrome measurement infidelity due to flag decay, but the trade-off is heavily favorable as logical errors are uncorrectable while syndrome errors are manageable by decoders.
Finite-Energy GKP Code (sBs Stabilization):
- Applied to the small-Big-small (sBs) stabilization protocol for GKP codes.
- The logical lifetime of the GKP code is extended significantly, approaching the bound set by a perfect (noiseless) ancilla.
- With realistic parameters (including flag decay and finite detection efficiency), the logical lifetime improves from $\approx 4$ ms (unflagged) to $\approx 170$ ms (flagged), a forty-fold improvement.
- The two-flag protocol is shown to be necessary to fully discretize the error channel and approach the theoretical limits.

Robustness to Imperfections
The paper analyzes the impact of experimental imperfections:

Finite Detection Efficiency: Requires a proportional increase in the flag photon number (resource overhead) but does not fundamentally break the protocol.
Flag Photon Loss: Acts as an effective dephasing channel on the ancilla. While this degrades the fidelity of the syndrome readout, it does not propagate as a continuous error to the memory and is less harmful than uncorrected ancilla decay.
Kerr Nonlinearity: Causes a deterministic shearing of the flag's phase-space distribution. This can be compensated for by recalibrating the control pulses and feedback angles.
Finite Pulse Durations: The protocol remains valid as long as the flag trajectories recombine at the end of the sequence; finite durations simply smooth the trajectories.

Significance and Claims
The authors claim that the continuous-variable flag is a general tool for hybrid oscillator-qubit processors. Its primary significance lies in:

Discretizing Continuous Errors: It converts uncorrectable continuous error channels into discrete errors that bosonic codes can handle, without requiring new hardware ingredients beyond an auxiliary oscillator.
Scalability: Unlike first-order protection schemes that rely on delicate matching conditions, this approach scales to higher orders of decay (especially with two flags) and is robust against experimental imperfections.
Fault Tolerance: By suppressing ancilla-induced logical errors by orders of magnitude, the protocol opens a route toward fault-tolerant simulation and computation using bosonic modes, addressing a primary bottleneck in current experimental implementations.

The paper concludes that while the measure-and-feedback architecture is demonstrated, the core principle of encoding error information into an auxiliary continuous-variable mode could also be realized via autonomous feedback schemes in future hardware implementations.

Technical Summary: Protecting Bosonic Codes from Ancilla-Induced Errors with Continuous-Variable Flags

More like this