A Concatenated Dual Displacement Code for Continuous-Variable Quantum Error Correction

1. Problem Statement

Continuous-Variable (CV) quantum computing utilizes harmonic oscillators (e.g., optical modes or superconducting resonators) to encode information. However, these systems face a fundamental limitation known as the Gaussian no-go theorem, which states that Gaussian operations and states alone cannot suppress Gaussian displacement errors (the dominant noise source in CV platforms).

Existing solutions, such as Gottesman-Kitaev-Preskill (GKP) codes, can correct small Gaussian displacements by mapping them to a lattice structure. However, GKP codes have a hard limit: if the displacement magnitude exceeds half the lattice spacing, a lattice-crossing error occurs, leading to logical failure. Furthermore, prior concatenation schemes (e.g., GKP + repetition codes) typically convert continuous errors into discrete Pauli errors, losing the analog nature of the CV system and requiring projective measurements. The challenge is to design a CV error correction architecture that:

1. Suppresses continuous Gaussian noise without collapsing it into discrete errors.
2. Corrects large, rare lattice-crossing and abrupt displacement errors.
3. Maintains the analog nature of the encoding to avoid the overhead of digitization.

2. Methodology

The authors propose a Concatenated Dual Displacement Code that integrates two layers of error correction, creating a functional duality based on the scale of the errors:

A. Inner Layer: Gaussian Error Suppression (GKP-Assisted)

• Mechanism: A 50:50 beam splitter entangles a data qumode with an ancillary GKP state.
• Operation: Syndrome extraction is performed via homodyne measurement of the position and momentum quadratures of the ancilla. The measurement outcomes are used to apply displacement gates to the data mode.
• Function: This layer acts as a continuous filter, suppressing small Gaussian displacement noise. It reduces the variance of the Gaussian noise acting on the data mode by a factor of two (50% variance reduction) under ideal conditions. It does not collapse the error into a discrete event but rather reduces the continuous variance.

B. Outer Layer: Analog Steane Code

• Mechanism: A CV analog version of the 7-qubit Steane code is constructed by replacing discrete Hadamard and CNOT gates with Fourier (F) and SUM (or SUM†) gates.
• Encoding: Logical information is encoded across 7 qumodes. The encoding circuit creates a specific superposition of position eigenstates that allows for the detection of displacement errors on individual modes.
• Syndrome Extraction: The system uses 3 ancilla qumodes per quadrature (position/momentum) coupled via SUM gates. Homodyne measurements yield a continuous syndrome vector ($s_1 \dots s_6$).
• Correction: Unlike digital codes that perform majority voting on discrete outcomes, this code uses analog decoding. The syndrome vector is analyzed to simultaneously estimate the location and magnitude of the displacement error. A displacement gate is then applied to correct the error.
• Function: This layer targets "lattice-crossing" events (errors too large for the inner GKP layer) and abrupt displacement errors (e.g., control pulse failures). It treats these as discrete jumps in the continuous space and corrects them directly.

C. The "Duality"

The core innovation is the separation of roles:

• Inner GKP: Handles continuous, small-scale Gaussian noise (variance reduction).
• Outer Steane: Handles discrete, large-scale lattice-crossing and abrupt errors (error localization and correction).
  This allows the system to operate entirely within the continuous variable framework without converting errors to a discrete Pauli basis.

3. Key Contributions

1. Novel Architecture: Introduction of a concatenated CV code combining GKP states (inner) and an analog Steane code (outer), specifically designed to handle both Gaussian and non-Gaussian (abrupt) displacement errors.
2. Analog Syndrome Extraction: Development of a complete operational framework for the analog Steane code, including explicit logical operations and a syndrome extraction circuit that yields continuous values for error magnitude and location, rather than binary outcomes.
3. Theoretical Analysis:
   • Proved that under infinite squeezing, the concatenated code suppresses Gaussian displacement variance by up to 50%.
   • Derived the probability of "miscorrection" (identifying the wrong qumode) as a function of the ratio between the error magnitude ($d$) and the residual noise standard deviation ($\sigma_{res}$).
   • Showed that the outer Steane code relaxes the squeezing requirements for the inner GKP states, making the scheme more feasible for near-term experiments.
4. Resource Efficiency Comparison: Demonstrated that the CV approach requires significantly fewer physical resources (states, gates, circuit depth) compared to digitizing the oscillator into qubits to achieve the same logical error rate.

4. Results

• Ideal Conditions (Infinite Squeezing): The inner GKP layer reduces the variance of Gaussian noise by half. The outer Steane code successfully corrects lattice-crossing errors with a success probability approaching 100% when the error magnitude is significantly larger than the residual noise ($d/\sigma_{res} \gtrsim 10$).
• Finite Squeezing (Realistic Conditions):
  • The scheme remains effective even with finite squeezing (e.g., 10–12 dB).
  • The residual variance decreases monotonically as squeezing strength increases.
  • For platforms like trapped ions (noise variance $\approx 0.03$), a squeezing level of $\sim 9.2$ dB is sufficient to observe a suppression gain.
• Monte Carlo Simulations:
  • Simulations over 1,000 rounds showed that without correction, variance grows linearly (random walk).
  • With GKP-only suppression, variance is reduced but lattice-crossing errors cause drift.
  • With the full concatenated code, the variance is suppressed close to the theoretical 50% limit, and the systematic drift caused by rare large errors is eliminated.
• Resource Comparison: To achieve a logical error rate of ~17.89%, the CV system required 15 physical states and a circuit depth of 3, whereas a qubit-based simulation (digitized oscillator) required 49 states and a depth of 36,788.

5. Significance

• Overcoming the No-Go Theorem: This work provides a viable route to fault-tolerant CV computation by circumventing the Gaussian no-go theorem through the strategic use of non-Gaussian resources (GKP) combined with analog correction, rather than relying solely on Gaussian operations.
• Experimental Feasibility: The architecture requires only one class of non-Gaussian resource (approximate GKP states). All other operations (beam splitters, SUM gates, homodyne detection) are Gaussian and compatible with current optical and superconducting platforms. The relaxation of squeezing requirements by the outer code makes near-term experimental demonstration highly probable.
• Hardware Efficiency: The paper highlights the inherent advantage of CV systems for bosonic error correction. By operating natively in the continuous phase space, it avoids the massive overhead associated with digitizing continuous variables into qubits.
• New Paradigm: It shifts the focus from "threshold-based fault tolerance" (which is theoretically impossible for oscillator-to-oscillator codes under finite squeezing) to "strong error suppression," enabling reliable, finite-depth quantum computations with significantly extended coherence times.

In summary, this paper establishes a robust, hardware-efficient framework for continuous-variable quantum error correction that effectively manages both the ubiquitous Gaussian noise and catastrophic large-displacement events, paving the way for scalable bosonic quantum computing.