Demonstration of High-Fidelity Entangled Logical Qubits using Transmons

This paper presents and experimentally demonstrates a hybrid quantum error correction and logical dynamical decoupling strategy on IBM transmon devices that significantly suppresses logical errors and enables the creation of high-fidelity entangled logical qubits.

The Gist

Imagine you are trying to send a very fragile, priceless message across a stormy ocean. The message is written on a piece of paper (your quantum bit, or qubit). The storm represents noise and errors that constantly try to tear the paper apart or scramble the ink.

In the world of quantum computing, keeping this message safe is incredibly hard. Scientists have developed two main strategies to protect the message, but both have flaws:

1. The "Error Correction" Strategy (QEC): Imagine you don't just send one piece of paper. You send four copies, arranged in a special pattern. If one copy gets a smudge, the other three can tell you what the original said. This is Quantum Error Correction (QEC).

   • The Problem: If the storm gets too crazy, or if the wind blows on two copies at the exact same time in a specific way, the four copies might all get corrupted in a way that looks like a valid message, but it's the wrong message. The system can't tell the difference. This is called a logical error.

2. The "Shaking the Table" Strategy (Dynamical Decoupling - DD): Imagine you have a table with a cup of water on it. If you shake the table back and forth very quickly in a specific rhythm, the water stays calm because the shaking cancels out the wobbles. This is Dynamical Decoupling (DD). It's like hitting the "undo" button on noise constantly.

   • The Problem: If you shake the table too hard or too clumsily, you might knock the cup over yourself (introducing new errors). Also, standard shaking doesn't always fix the specific way the wind is blowing in this quantum storm.

The Big Breakthrough: The "Super-Shaker"

This paper introduces a brilliant new hybrid strategy called QEC-NDD (Quantum Error Correction + Normalizer Dynamical Decoupling).

Think of it this way: Instead of just using the four copies of the paper (QEC) OR just shaking the table (DD), the scientists decided to use the four copies themselves to shake the table.

Here is the analogy:

• The Setup: You have a team of four guards (the 4 physical qubits) protecting a secret (the logical qubit).
• The Old Way: The guards stand still and watch for intruders (QEC). If two intruders attack at once, the guards get confused.
• The New Way (NDD): The guards are trained to perform a specific, synchronized dance routine. This dance routine is designed so that every time they move, they cancel out the wind (noise) trying to blow them over.
• The Magic: The dance moves are chosen specifically because they are the "safe moves" for the secret. If the guards do the dance, they protect the secret and they shake off the noise at the same time.

What Did They Actually Do?

The researchers used a real quantum computer (IBM's "Kyiv" processor) with 127 qubits. They focused on a specific code called the [[4, 2, 2]] code.

• Think of this as a "4-to-2" translator. They took 4 physical qubits and turned them into 2 "logical" qubits (super-protected qubits).
• They created entangled logical qubits. Entanglement is like a magical link where two particles are connected; if you change one, the other changes instantly, no matter how far apart they are. Keeping this link alive is the "holy grail" of quantum computing.

The Experiment:

1. They created these entangled logical qubits.
2. They let them sit there for a while (simulating the passage of time).
3. They tested three scenarios:
   • No Protection: The qubits just sat there. (Result: The message got garbled very quickly).
   • Just the Dance (DD): They used standard shaking techniques. (Result: Better, but still noisy).
   • The Hybrid (QEC-NDD): They used the special "guard dance" (NDD) combined with the error-checking system.

The Results: "Beyond Breakeven"

The paper reports a massive success. They achieved what is called "Beyond Breakeven."

In everyday terms:

• Breakeven is the point where your fancy protection system works better than just doing nothing.
• Beyond Breakeven means their system didn't just work; it worked significantly better than the best unprotected qubits could possibly do.

They managed to keep the entangled logical qubits connected with 90%+ fidelity (accuracy) for a surprisingly long time (55 microseconds). In the quantum world, that's an eternity!

Why Does This Matter?

1. It's Cheaper: Usually, to fix errors, you need huge codes with hundreds of qubits. This method shows you can get amazing results with a tiny code (just 4 qubits) if you use the right "dance moves."
2. It's Robust: The "dance" they designed is smart. It handles the specific type of noise that happens in real computers (called "crosstalk," where one qubit accidentally talks to its neighbor) better than standard methods.
3. It's a Step Toward the Future: To build a useful quantum computer that can solve real-world problems (like designing new medicines or breaking encryption), we need logical qubits that don't die instantly. This paper proves that we can build these "super-qubits" that are stronger than the sum of their parts.

Summary

Imagine you are trying to keep a group of dancers perfectly in sync while a hurricane blows through the room.

• Old way: You just tell them to stand still and hope the wind doesn't knock them over. (They fall).
• Second way: You tell them to run in circles to cancel the wind. (They get dizzy and fall).
• This paper's way: You teach them a specific, synchronized dance where their movements naturally cancel out the wind and they hold hands so if one stumbles, the others pull them back up.

The result? The dancers stay in perfect sync, even in the hurricane. This is a giant leap toward building a quantum computer that actually works.

Technical Summary

Here is a detailed technical summary of the paper "Demonstration of High-Fidelity Entangled Logical Qubits using Transmons."

1. Problem Statement

Quantum Error Correction (QEC) is essential for fault-tolerant quantum computing, but standard QEC codes face a fundamental limitation: they cannot detect logical errors (errors that act as valid logical operators within the code space).

• The Challenge: As quantum algorithms scale, low-weight physical errors can accumulate or correlate (e.g., via long-range crosstalk) to form high-weight errors that transform into logical errors.
• The Limitation of Current Methods:
  • Increasing code distance (e.g., surface codes) to handle these errors incurs massive overhead in physical qubits and decoding time.
  • Standard Dynamical Decoupling (DD) applied at the physical qubit level can suppress noise but often introduces new errors due to control imperfections and crosstalk, potentially negating its benefits.
  • Existing hybrid approaches often fail to suppress logical errors effectively without compromising the QEC code's ability to detect physical errors.

2. Methodology

The authors propose and implement a hybrid strategy called QEC-NDD (Quantum Error Correction combined with Normalizer Dynamical Decoupling).

A. Theoretical Framework: Normalizer Dynamical Decoupling (NDD)

• Concept: Instead of using physical Pauli operators for DD pulses, the authors use elements from the normalizer group ($N(S)$) of the QEC code. The normalizer contains both the stabilizers ($S$) and the logical operators ($L$).
• Mechanism:
  • Stabilizer DD (SDD): Suppresses detectable errors but not logical errors.
  • Logical DD (LDD): Suppresses logical errors but leaves detectable errors to the QEC cycle.
  • NDD: Uses subgroups of the normalizer (combinations of stabilizers and logical operators) to construct pulse sequences that simultaneously suppress logical errors and are robust against physical control errors and crosstalk.
• Robustness: The sequences are designed to be "universally robust" (UR) against pulse errors (axis-angle and magnitude deviations) and "staggered" to cancel out nearest-neighbor crosstalk (specifically ZZ interactions).

B. Experimental Setup

• Hardware: IBM Quantum processors (IBM Kyiv and IBM Marrakesh) featuring fixed-frequency transmon qubits.
• Code: The [[4, 2, 2]] quantum error detection code. This code encodes 2 logical qubits into 4 physical qubits. It has a distance of $d=2$, meaning it can detect any single-qubit error but cannot correct them; however, it cannot detect weight-2 logical errors (like ZZ crosstalk) without additional measures.
• Target State: Logically encoded Bell states ($|\Phi^\pm\rangle, |\Psi^\pm\rangle$).
• Error Detection Strategy: Since the [[4, 2, 2]] code cannot natively detect logical errors, the authors designed a specific protocol:
  1. Encode a logical Bell state $|\chi\rangle$.
  2. Let it evolve (with or without NDD).
  3. Unencode into a different logical Bell state $|\chi'\rangle$ (e.g., $|\Phi^+\rangle \to |\Phi^-\rangle$).
  4. If a specific logical error occurred (e.g., a $Z$ error), the state $|\chi\rangle$ becomes $|\chi'\rangle$. Measuring the ground state ($|0000\rangle$) after unencoding into $|\chi'\rangle$ signals the occurrence of that specific logical error.
  5. Post-selection: Measurement outcomes corresponding to odd Hamming weights (physical errors) are discarded. Only even-weight outcomes (logical space) are kept for fidelity calculation.

C. Pulse Sequences Tested

• Physical DD: Standard XY4 and robust sequences (URn) applied to idle gaps.
• NDD Sequences:
  • RNXX: Robust Normalizer XX sequence.
  • RNXY4: Robust Normalizer XY4 sequence (using logical operators and stabilizers to create a 4-pulse logical cycle that maps to robust physical cycles).
  • SXY4: Staggered physical XY4 (applied to physical qubits to reduce crosstalk).

3. Key Contributions

1. Proposal of QEC-NDD: A novel hybrid strategy that uses the normalizer elements of a QEC code as DD pulses to suppress arbitrary-weight errors, specifically targeting logical errors that standard QEC misses.
2. Logical Error Detection Protocol: A method to unequivocally detect logical errors in a low-distance code (distance-2) by leveraging the permutation properties of logical Bell states and specific unencoding circuits.
3. Robust Sequence Design: The design of NDD sequences that are simultaneously robust to control errors (pulse imperfections) and crosstalk (ZZ interactions) at the physical level, ensuring the DD pulses do not introduce new logical errors.
4. Beyond-Breakeven Demonstration: The first experimental demonstration of entangled logical qubits with fidelities significantly exceeding those of the best unprotected (physical) entangled qubits in the same environment.

4. Experimental Results

Experiments were conducted on 24 sets of 4-qubit configurations across two IBM processors.

• Suppression of Logical Errors:
  • Without DD, logical Bell state fidelity decayed rapidly (dropping to ~20% in ~10 µs) due to ZZ crosstalk.
  • Standard NDD (NXX, NXY4) improved fidelity at short times but suffered from coherent errors (oscillations) at longer times.
  • Robust NDD (RNXX, RNXY4) significantly suppressed logical Z-errors and eliminated oscillations, maintaining high fidelity over 55 µs.
• Physical Error Suppression:
  • NDD sequences were shown to suppress physical errors (detected via post-selection discard rates) in addition to logical errors.
  • Data discard rates were significantly lower with NDD compared to "No DD," indicating fewer physical errors occurred.
• Fidelity Benchmarks (Dataset 2):
  • No DD + Post-selection: ~35% fidelity.
  • NDD alone (RNXY4): ~82-87% fidelity (depending on the state).
  • NDD + Post-selection (RNXY4+PS): Achieved average fidelities of 91.12% ($|\Phi^+\rangle$) and 93.66% ($|\Psi^+\rangle$) over 55 µs.
  • Best Case: For a specific set of high-quality qubits, the combination of NDD and post-selection achieved ~95.44% fidelity for $|\Phi^+\rangle$ and ~94.78% for $|\Psi^+\rangle$.
• Beyond Breakeven:
  • The best physical Bell pairs (even with staggered XY4) reached ~71% fidelity after 55 µs.
  • The logical Bell pairs with QEC-NDD achieved >92% fidelity, clearly demonstrating beyond-breakeven performance (logical qubits outperforming physical qubits).
  • These results surpass previous state-of-the-art results using surface codes (e.g., Ref [90] reported ~79.5%; Ref [91] reported ~93.7% peak but dropped to ~30% after 5 rounds).

5. Significance

• Scalability: This work demonstrates that high-fidelity logical qubits can be achieved without the massive overhead of large-distance codes (like surface codes). By combining small codes with intelligent dynamical decoupling, the system remains "nimble" while effectively handling errors.
• Error Handling: It addresses the critical gap in current QEC: the inability to detect and suppress logical errors arising from correlated noise (crosstalk).
• Practicality: The method is compatible with current superconducting hardware (transmons) and leverages existing control capabilities (virtual Z gates, robust pulse sequences).
• Future Path: The results provide a viable pathway toward fault-tolerant quantum computing by showing that logical entanglement can be preserved at fidelities required for useful algorithms, even in the presence of significant crosstalk.

In summary, the paper establishes that Normalizer Dynamical Decoupling is a powerful tool to bridge the gap between current noisy intermediate-scale quantum (NISQ) devices and future fault-tolerant systems, achieving record-breaking fidelities for entangled logical qubits.