Entanglement-assisted continuous-variable concatenated codes for encoding qubits or oscillators

This paper proposes and analyzes entanglement-assisted continuous-variable concatenated codes that combine entanglement-assisted stabilizer codes with Gottesman-Kitaev-Preskill (GKP) codes to enhance error correction rates and suppress quadrature error variances for both qubit-into-oscillator and oscillator-into-oscillator encoding schemes.

The Gist

Imagine you are trying to send a very fragile message across a noisy, stormy ocean. In the quantum world, this "message" is information (like a qubit), and the "storm" is random noise that can scramble or destroy the data.

This paper proposes a new, super-efficient way to protect that message by combining two different types of safety nets: entanglement (a spooky quantum connection) and concatenated codes (a "box-in-a-box" strategy).

Here is the breakdown of their ideas using everyday analogies:

1. The Two Safety Nets

To understand the paper, you first need to know the two tools they are mixing:

• The "Quantum Rope" (GKP Codes): Imagine your message is a delicate string. The GKP code is like weaving that string into a thick, woven rope. If the wind (noise) pushes the rope slightly, the weave holds it in place. It's great at fixing small, random bumps in the position or momentum of the message.
• The "Quantum Handshake" (Entanglement-Assisted Codes): Imagine you and your friend have a secret, pre-shared connection. Even if you are miles apart, if you both hold one half of a "magic coin," you can use that connection to fix errors faster than if you were working alone. This is called "entanglement assistance." It speeds up error correction but requires you to share these magic coins beforehand.

2. The "Box-in-a-Box" Strategy

The paper explores two ways to stack these safety nets. Think of it like packing a fragile vase for shipping.

Approach A: The "Outer Box" Strategy (Qubits inside Oscillators)

• How it works: First, you wrap your message in a standard "Quantum Rope" (GKP). Then, you take that wrapped rope and put it inside a "Quantum Handshake" box (Entanglement-Assisted code).
• The Analogy: You wrap the vase in bubble wrap (GKP), and then you put that wrapped vase into a crate where you and the receiver have a pre-shared radio link (Entanglement) to coordinate the shipping.
• The Result: The authors tested this with a specific setup (a 3-qubit repetition code). They found that because the receiver has the "magic coins" (entanglement) ready to go, this method is very good at fixing errors. It actually performed better than a famous 5-qubit code that doesn't use this pre-shared help.

Approach B: The "Inner Box" Strategy (Oscillators inside Qubits)

• How it works: This is the reverse. First, you use the "Quantum Handshake" to protect the message. Then, you wrap that whole protected package in the "Quantum Rope" (GKP).
• The Analogy: You and the receiver first link up via your magic radio (Entanglement) to create a secure channel. Then, you wrap the message in bubble wrap (GKP) before sending it through that channel.
• The Result: This is the paper's big breakthrough. By using this order, they discovered a way to smooth out both types of noise (position and momentum) simultaneously.
  • The Magic Math: If you use 2 magic coins (entangled modes), you can reduce the "shaking" of the message by a factor of 3.
  • The General Rule: If you use $n-1$ magic coins, you can reduce the shaking by a factor of $n$.
  • Example: If you use 9 magic coins, you make the noise 10 times smaller.

3. Why This Matters (According to the Paper)

The paper claims that by mixing these two concepts, they created a system that is:

1. Resource-Thrift: It uses the "magic coins" efficiently.
2. High Performance: It significantly lowers the chance that the message will fail (logical failure probability).
3. Versatile: They showed how to do this for both sending simple bits (qubits) and sending continuous waves (oscillators).

What They Did Not Claim

It is important to stick to what the paper actually says:

• They did not claim this is ready for commercial use today.
• They did not claim it works for medical devices or clinical uses.
• They did not claim it solves all quantum problems.
• They explicitly noted their calculations assume "ideal" conditions (perfect magic coins and no other types of noise besides simple shaking). They suggest that future work could test this with real-world imperfections, but they haven't done that yet.

The Bottom Line

The authors built a theoretical "super-packaging" system for quantum information. By using a pre-shared quantum connection (entanglement) to help a specific type of error-correcting code (GKP), they found a way to make the message much more stable against noise. They proved that the more "magic coins" (entanglement) you share, the smoother and safer your quantum message becomes.

Technical Summary

Technical Summary: Entanglement-assisted continuous-variable concatenated codes for encoding qubits or oscillators

Problem Statement
Quantum error correction (QEC) is essential for fault-tolerant quantum computing. While stabilizer codes are effective for discrete-variable (DV) systems, continuous-variable (CV) systems (bosonic modes) require specific codes like the Gottesman-Kitaev-Preskill (GKP) code to correct small shift errors in phase space. Hybrid approaches, such as concatenating DV stabilizer codes with CV GKP codes, have been explored to improve error correction performance. However, these conventional concatenations do not utilize pre-shared entanglement. Entanglement-assisted (EA) stabilizer codes are known to enhance transmission rates and error correction capabilities by relaxing the requirement for self-dual stabilizer groups, provided the sender and receiver share entangled bits (ebits). The central problem addressed in this work is how to integrate EA assistance into concatenated CV-stabilizer codes to further enhance error suppression and logical failure probabilities, specifically for encoding both qubits and oscillators.

Methodology
The authors propose two distinct concatenation architectures combining EA-stabilizer codes and GKP codes, denoted by the notation $A \triangleright B$, where $A$ is the outer code and $B$ is the inner code.

1. $C_{EA-stabilizer} \triangleright C_{GKP}$ (Qubit-into-Oscillator):

   • Structure: An outer EA-stabilizer code (DV) is concatenated with an inner GKP code (CV).
   • Process: A logical qubit is first encoded into a physical qubit state using an EA-stabilizer code (utilizing pre-shared ebits). Subsequently, each physical qubit and the halves of the ebits are encoded into computational GKP states (oscillators).
   • Example: The authors analyze a $[[3, 1, 3; 2]]$ EA-repetition code concatenated with a GKP code. The outer layer encodes one logical qubit into three physical qubits using two pre-shared ebits. The inner layer encodes these three qubits and the two ebit halves into five harmonic oscillators.
   • Decoding: CV errors are corrected on individual modes first, followed by the correction of discrete errors using the EA-stabilizer syndromes.

2. $C_{GKP} \triangleright C_{EA-stabilizer}$ (Oscillator-into-Oscillators):

   • Structure: An outer GKP code is concatenated with an inner EA-stabilizer code.
   • Process: A single-mode GKP encoded state is first produced. This state is then encoded into multiple oscillator modes using a Gaussian encoder derived from an EA-stabilizer code, utilizing pre-shared GKP Bell states (entangled modes or emodes).
   • Example: The authors propose a $C_{GKP} \triangleright C_{[[3, 1, 3; 2]]}$ code. A single logical GKP state is encoded into three oscillator modes using two pre-shared GKP Bell pairs (emodes). The encoding utilizes a Gaussian unitary encoder ($U^G_{enc}$) composed of SUM gates.
   • Decoding: The system employs syndrome measurements on the stabilizers of the data mode and the ancillary emodes. Since the data mode syndromes cannot be directly measured without disturbing the state, the authors use maximum likelihood estimation (MLE) to infer the most probable error values based on the measured syndromes of the ancillary modes and the assumption of independent and identically distributed (iid) Gaussian noise.

Key Contributions and Results

• Proposal of EA Concatenated Codes: The paper introduces and formalizes two new families of concatenated codes: $C_{EA-stabilizer} \triangleright C_{GKP}$ and $C_{GKP} \triangleright C_{EA-stabilizer}$.
• Noise Suppression in $C_{GKP} \triangleright C_{EA-stabilizer}$:
  • For the specific case of $C_{GKP} \triangleright C_{[[3, 1, 3; 2]]}$, the authors demonstrate that using two maximally entangled modes (emodes) allows for the suppression of variances in both position ($q$) and momentum ($p$) quadrature errors of the data mode by a factor of $1/3$.
  • The residual logical errors follow a Gaussian distribution with variance $\sigma^2/3$, compared to the original variance $\sigma^2$.
  • This is achieved without additional quadrature squeezing, relying instead on the entanglement assistance.
• Generalization to $n$-qubit EA Repetition Codes:
  • The authors generalize the $C_{GKP} \triangleright C_{[[3, 1, 3; 2]]}$ scheme to a family of codes: $C_{GKP} \triangleright C_{[[n, 1, n; n-1]]}$, where $n$ is an odd integer $\ge 3$.
  • Theorem 1: This family uses $n-1$ emodes to suppress the variance of both position and momentum quadrature errors of a data mode by a factor of $1/n$.
  • This result is compared to unbiased GKP-repetition codes from prior literature (Ref. [28]), noting that the proposed EA scheme achieves similar suppression factors ($1/(n+1)$ for $n+1$ modes) but with a different resource structure (using $n-1$ emodes for $n$ total modes in the repetition context).
• Performance Comparison:
  • The logical failure probability for $C_{[[3, 1, 3; 2]]} \triangleright C_{GKP}$ is calculated and shown to outperform the $C_{[[5, 1, 3]]} \triangleright C_{GKP}$ code (a standard qubit-into-oscillator code without EA assistance). This improvement is attributed to the outer EA code having noiseless halves of ebits in the receiver's possession.
  • Conversely, the $C_{GKP} \triangleright C_{[[3, 1, 3; 2]]}$ code (oscillator-into-oscillator) is found to have a higher logical failure probability than its $C_{[[3, 1, 3; 2]]} \triangleright C_{GKP}$ counterpart. The authors attribute this to the necessity of estimating unmeasured states in the former, whereas the latter allows for a full suite of EA stabilizer measurements.

Significance and Claims
The paper claims to extend recent comparative studies of $C_{stabilizer} \triangleright C_{GKP}$ and $C_{GKP} \triangleright C_{stabilizer}$ codes to their entanglement-assisted counterparts. The primary significance lies in demonstrating that entanglement assistance can be effectively integrated into CV concatenated codes to:

1. Enhance error correction rates and reduce logical failure probabilities in qubit-into-oscillator schemes.
2. Provide a mechanism to suppress variances in both quadratures of an oscillator data mode by a factor of $1/n$ using $n-1$ entangled modes, offering a resource-efficient alternative to schemes requiring additional squeezing or more ancillary modes.

The authors maintain a modest scope, noting that their analysis assumes ideal GKP states and Gaussian shift errors. They acknowledge that while their results are promising, practical implementation would require addressing finite-energy effects, non-Gaussian noise channels (like pure-loss), and fault-tolerant thresholds under realistic hardware constraints. They suggest that these frameworks could be applied to quantum repeaters and distributed sensing, but do not propose specific experimental setups beyond referencing existing platforms (trapped ions, superconducting circuits, photonics) capable of generating the necessary states.