Error Correction of Beamsplitter-Generated Entangled GKP States

Using two motional modes of a trapped ion, researchers demonstrated the generation of entangled GKP Bell states via beamsplitter interference and successfully extended their lifetime through quantum error correction, thereby completing the set of Gaussian operations required for fault-tolerant GKP-based quantum computing.

The Gist

The Big Picture: Fixing the "Fragile" Computer

Imagine you are trying to build a super-fast computer that uses the weird rules of quantum mechanics. The problem is that these computers are incredibly fragile. Like a house of cards in a windy room, the slightest bump (noise or error) causes the information to collapse.

To fix this, scientists use Error Correction. Think of this as building a sturdy cage around your house of cards. If the wind blows, the cage protects the cards, and if a card falls, the cage helps you put it back in the right spot.

This paper is about building a specific, very efficient type of cage called a GKP code (named after Gottesman, Kitaev, and Preskill). Instead of using many tiny, separate cards (physical qubits) to make one strong card, this code uses the infinite possibilities of a single "vibrating" system (like a swinging pendulum) to hold the information.

The Main Achievement: The "Quantum Dance"

The researchers successfully performed two major tasks with these GKP codes using a single trapped ion (a charged atom held in place by electric fields):

1. Creating Entangled Pairs (The Bell States):
   They took two separate "vibrating" modes of the ion and made them dance together. In quantum physics, this is called entanglement. When two things are entangled, they become a single team; if you check one, you instantly know the state of the other, no matter how far apart they are.

   • The Analogy: Imagine two dancers. Before the experiment, they are practicing alone in separate rooms. The researchers used a special "beam splitter" (a device that mixes two paths, like a mirror that splits a laser beam) to make them dance a synchronized routine together. They managed to create four different types of synchronized dances (called Bell states) with about 69% accuracy.

2. Extending the Dance's Life (Error Correction):
   Entangled states usually fall apart very quickly because of noise (like a dancer getting tired or distracted). The researchers then applied their "cage" (error correction) to the dancing pair.

   • The Result: The error correction acted like a coach who constantly watches the dancers and gently nudges them back into step whenever they wobble. This doubled the amount of time the entangled state could survive compared to if they had done nothing.

How They Did It: The "Qunaught" Trick

To get the dancers ready, they didn't start with perfect dancers. They started with "qunaught" states.

• The Analogy: Think of a GKP state as a perfect grid of dots on a piece of paper. A "qunaught" state is like a grid that is slightly blurry or has the dots shifted. It looks like the right pattern, but it doesn't hold any actual secret message (logical information) yet.
• The Magic Move: The researchers took two of these "blurry grid" states and mixed them together using the beam splitter. Because of the way the grids were aligned, when they mixed, the blurriness canceled out in a specific way, and the result was a sharp, perfect, entangled grid holding a secret message. It's like taking two slightly out-of-focus photos and combining them to create one perfectly sharp image.

Why This Matters

This experiment is a crucial step toward building a real, fault-tolerant quantum computer.

• The Toolkit: To build a quantum computer, you need a full set of tools (operations). The researchers showed that they can now mix these GKP states together (the beam splitter) just like they can squeeze them or move them. This completes the basic "Gaussian toolbox" needed to manipulate these codes.
• The Future: By proving they can entangle these states and then fix errors in them, they have shown a path forward for building larger, more complex quantum systems that don't fall apart when the real world gets noisy.

Summary of the Experiment

1. Preparation: They trapped a Calcium ion and made it vibrate in two different ways.
2. Shaping: They shaped these vibrations into "qunaught" states (grid-like structures without data).
3. Mixing: They used a beam splitter to mix the two vibrations, turning them into entangled "Bell states" (data-carrying pairs).
4. Protection: They applied error correction, which doubled the time the entangled state could survive before falling apart.

In short, they successfully built a quantum "house of cards," put it in a protective cage, and showed that the cage works to keep the cards standing longer.

Technical Summary

Technical Summary: Error Correction of Beamsplitter-Generated Entangled GKP States

Problem Statement
Quantum computing requires hardware-level error correction to function reliably at scale. While bosonic codes offer a hardware-efficient approach by utilizing the infinite-dimensional Hilbert space of a single harmonic oscillator, fault tolerance demands that the physical gate interactions be compatible with the code structure. The Gottesman-Kitaev-Preskill (GKP) code is a leading candidate, capable of correcting low-order errors via simple physical operations. However, a critical gap existed in experimental implementations: while single-mode GKP states had been demonstrated, direct interactions between GKP states had not been realized in a fault-tolerant manner. Previous two-qubit gates relied on non-encoded (bare) qubits as intermediaries, which is inherently non-fault-tolerant. To build larger systems, a primitive interaction that preserves the code structure while generating entanglement is required.

Methodology
The authors implemented a protocol using two motional modes of a single trapped $^{40}\text{Ca}^+$ ion confined in a segmented Paul trap. The experimental approach involved three primary stages:

1. Preparation of Qunaught States: The team prepared "qunaught" states ($|\emptyset\rangle$) in two separate bosonic modes. These states possess a grid-like structure in phase space but carry no logical information. They were generated by squeezing the modes and applying a sequence of state-dependent forces (SDFs) to create a periodic lattice. Four specific combinations of these states ($|\emptyset\rangle \otimes |\emptyset\rangle$, $|\emptyset\rangle_q \otimes |\emptyset\rangle_q$, $|\emptyset\rangle_p \otimes |\emptyset\rangle_p$, and $|\emptyset\rangle_{qp} \otimes |\emptyset\rangle_{qp}$) were prepared to serve as inputs.
2. Beamsplitter Interaction: A resonant mode-to-mode coupling was realized by modulating the trap curvature at the difference frequency between the two modes. This implemented an effective Hamiltonian $\hat{H}_{BS} = \hbar g(\hat{q}_1\hat{p}_2 - \hat{p}_1\hat{q}_2)$, acting as a 50/50 beamsplitter. The interaction duration was set to $gt = \pi/4$. Theoretically, this operation rotates the phase space by $\pi/4$, transforming the separable qunaught product states (which have a lattice spacing differing by a factor of $\sqrt{2}$ from the GKP qubit code) into entangled GKP Bell states.
3. Readout and Error Correction: To characterize the states, the team measured the two-mode characteristic function. They employed a finite-energy corrected readout technique, using conditional displacements on an ancilla qubit to compensate for the loss of contrast caused by the finite energy of the GKP states. Following entanglement generation, multiple rounds of quantum error correction (QEC) were performed on each mode to extend the logical lifetime of the state.

Key Contributions

• First Direct GKP-GKP Interaction: The work demonstrates the first direct interaction between GKP states using a beamsplitter primitive, avoiding the use of non-encoded intermediate qubits.
• Generation of All Four Bell States: The experiment successfully generated all four logical Bell states of GKP qubits by interfering specific qunaught states.
• Extension of Entangled State Lifetime: The authors demonstrated that applying error correction to the entangled state extends its logical lifetime beyond the bare coherence time of the system.
• Completion of Gaussian Toolbox: By combining the beamsplitter with available single-mode squeezing and displacements, the work completes the set of Gaussian operations required for quantum computing with GKP codes on a two-mode phase space.

Results

• Fidelity: The four Bell states were generated with fidelities of $0.72(2)$, $0.66(2)$, $0.73(2)$, and $0.67(2)$, resulting in an average Bell state fidelity of $0.69(1)$.
• Lifetime Extension: For the $|\Psi^+\rangle$ Bell state, the logical lifetime was extended by a factor of $2.0(2)$ through error correction. Specifically, the lifetimes for the logical Pauli operators $\langle X_{L,1}X_{L,2}\rangle$, $\langle Y_{L,1}Y_{L,2}\rangle$, and $\langle Z_{L,1}Z_{L,2}\rangle$ increased from approximately 2.3–2.4 ms (without correction) to 3.8–5.3 ms (with correction).
• Limitations: The fidelity is currently limited by dephasing of the motional oscillator and the ancilla qubit, as well as the duration of the beamsplitter interaction. The extension of the lifetime for the $\langle Y_{L,1}Y_{L,2}\rangle$ operator was less pronounced due to finite energy effects and increased susceptibility to dephasing noise.

Significance
The paper claims that these results complete the necessary set of Gaussian operations for GKP-based quantum computing, enabling the construction of fault-tolerant multi-qubit gates. The demonstrated primitives are essential for exploring multi-mode bosonic encodings (such as the D4 code or Tesseract code) and for fundamental tests of information channels. Furthermore, the techniques developed here are central to theoretical proposals for measurement-based error correction, teleportation-based GKP error correction, and quantum transduction protocols. The work establishes a pathway toward scaling GKP codes by incorporating additional oscillators, potentially through increased ion numbers or longer ion chains.