⚛️ quantum physics

Low-valency scalable quantum error correction with a dynamic compass code

This paper introduces the dynamic compass code, a scalable quantum error-correcting scheme for the heavy-hex lattice that utilizes a novel syndrome extraction schedule to achieve a stability threshold, offer tunable protection against X and Z errors, and enable fault-tolerant lattice surgery.

Original authors: Jun Zen, Xanda C. Kolesnikow, Campbell K. McLauchlan, Georgia M. Nixon, Thomas R. Scruby, Seok-Hyung Lee, Stephen D. Bartlett, Benjamin J. Brown, Robin Harper

Published 2026-04-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jun Zen, Xanda C. Kolesnikow, Campbell K. McLauchlan, Georgia M. Nixon, Thomas R. Scruby, Seok-Hyung Lee, Stephen D. Bartlett, Benjamin J. Brown, Robin Harper

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

Imagine you are trying to build a super-advanced computer that can solve problems no regular computer ever could. This is a quantum computer. But there's a huge catch: these computers are incredibly fragile. The slightest whisper of noise, a tiny vibration, or a stray heat wave can cause them to make mistakes. It's like trying to balance a house of cards in a hurricane.

To fix this, scientists use Quantum Error Correction. Think of this as a team of vigilant guards watching over the house of cards. If one card starts to wobble, the guards fix it before the whole thing collapses.

However, building these "guards" is hard. They usually require a massive amount of extra hardware (more cards than you have information to store), and they need to be connected in very specific, complex ways that current technology struggles to build.

This paper introduces a new, smarter way to build these guards called the Dynamic Compass Code. Here is the breakdown in simple terms:

1. The Problem: The "Heavy-Hex" Lattice

Current quantum computers (like those from IBM) are built on a specific grid pattern called a Heavy-Hex lattice. Imagine a honeycomb, but with some extra heavy beams. It's a great design because it's easy to build, but it has a limitation: every piece can only touch three neighbors.

Previous error-correcting codes tried to work on this grid, but they had a fatal flaw. They were great at catching one type of mistake (let's call them "X-mistakes") but terrible at catching the other type ("Z-mistakes"). It was like having a security system that was great at spotting thieves but completely blind to fire. As the computer got bigger, the system would eventually fail because it couldn't handle the "Z-mistakes."

2. The Solution: The "Dynamic" Approach

The authors realized that instead of checking the system in a boring, repetitive loop (Check X, Check Z, Check X, Check Z...), they could change the schedule of the checks.

Think of it like a dance routine.

The Old Way: The dancers (the quantum checks) all move in a rigid, predictable pattern. Eventually, a specific type of error slips through the cracks because the pattern is too static.
The New Way (Dynamic Compass Code): The dancers change their steps based on the music. Sometimes they check the floor, sometimes the walls, and they do it in a specific rhythm that evolves over time.

By carefully choreographing when and what they measure, the team created a code that:

Fits perfectly on the existing "Heavy-Hex" hardware (no need to build new machines).
Catches both X and Z mistakes effectively.
Scales up: As you make the computer bigger, the error rate actually goes down, which is the "holy grail" of quantum computing.

3. The "Compass" Metaphor

The code is called a "Compass Code" because it uses a mathematical model similar to how a compass works. In a compass, magnets align in specific directions (North-South or East-West).

In the old code, the "magnets" were stuck in a way that made them vulnerable to one direction of wind (noise).
In this new Dynamic Compass Code, the team figured out how to rotate the compass dynamically. By changing the measurement order, they keep the "magnets" aligned just right to block errors from any direction, without needing extra hardware.

4. Why "Low-Valency" Matters

"Valency" is a fancy word for "how many neighbors something has."

Most error-correcting codes require a piece of hardware to talk to 4, 5, or even more neighbors. This is hard to build.
This new code only needs each piece to talk to 3 neighbors (Low-Valency).
Analogy: Imagine a neighborhood where every house only needs to talk to 3 neighbors to stay safe. This is much easier to build than a neighborhood where every house needs to talk to 10 neighbors. This makes the code "scalable," meaning we can build huge quantum computers with it using today's technology.

5. The "Stability" Test

The paper also tested something called "Stability." Imagine you are trying to keep a secret message safe while you are moving it from one room to another (this is called Lattice Surgery).

The old code would lose the message during the move if the noise was too high.
The new Dynamic Compass Code proved it could keep the message safe even while moving it around, showing it has a "threshold." This means if the hardware is good enough (below a certain noise level), the computer can run forever without crashing.

The Big Picture

This paper is a blueprint for a practical quantum computer.

Before: We had great theories, but they required hardware that didn't exist yet, or they failed as soon as the computer got big.
Now: We have a "Dynamic Compass Code" that fits on hardware we can build today (IBM's heavy-hex chips), catches all types of errors, and gets better as it gets bigger.

The authors even tested a small version of this on a real IBM quantum computer and it worked! This is a major step toward the day when quantum computers can solve real-world problems like designing new medicines or cracking complex encryption, all while staying stable and error-free.

1. Problem Statement

The realization of large-scale, fault-tolerant quantum computers requires quantum error-correcting codes (QECCs) that satisfy two conflicting constraints:

Hardware Compatibility: They must be implementable on near-term hardware with limited connectivity (specifically, low-degree connectivity where qubits couple to at most three neighbors, such as the heavy-hex lattice used by IBM).
Scalability: They must demonstrate a threshold, meaning logical error rates must vanish exponentially as the code distance ( $d$ ) increases.

The Specific Challenge:
The heavy-hex code, a subsystem code designed for low-connectivity hardware, suffers from a critical flaw: while it has a threshold for $Z$ -basis errors, it lacks a threshold for $X$ -basis errors. In the standard measurement schedule, $X$ -stabilizers become "extensive" (spanning the entire lattice), leading to detectors with weights that scale with the system size ( $O(d)$ ). As the code grows, these high-weight detectors become unreliable, preventing scalable fault tolerance. Additionally, the heavy-hex code lacks a threshold for stability experiments (crucial for lattice surgery and logical gate operations).

2. Methodology

The authors propose a new family of codes called Dynamic Compass Codes, derived by applying a novel dynamic measurement schedule to the gauge group of the heavy-hex code.

Theoretical Framework:
- Compass Codes: Utilize a gauge group generated by interaction terms of a compass model (specifically the heavy-hex model).
- Dynamic (Floquet) Codes: Instead of a static stabilizer group, the code evolves over time based on the order of measurements. The authors utilize the Instantaneous Stabilizer Group (ISG) formalism to track the code's state.
- Key Innovation: By carefully ordering the measurement of gauge operators (specifically omitting certain $Z$ -checks at specific time steps), the authors transform the heavy-hex subsystem code into a dynamic code with constant-weight stabilizers.
Measurement Schedule:
- The proposed schedule has a period of 4 steps.
- Steps 1 & 3: Measure all $X$ -checks.
- Steps 2 & 4: Measure specific subsets of $Z$ -checks.
- Omission Strategy: By omitting certain $Z$ -gauge measurements (specifically those that would factorize intermediate $Z$ -stabilizers), the authors prevent $X$ -stabilizers from growing to extensive weights. This creates a trade-off: reducing $Z$ -measurement frequency improves $X$ -protection but degrades $Z$ -protection.
Simulation & Decoding:
- Noise Model: Uniform circuit-level noise (including depolarizing, idling, and measurement errors) on a heavy-hex lattice.
- Decoder: Minimum-weight perfect matching (MWPM) using the PyMatching library.
- Circuit Implementation: Simulations were performed both with and without qubit resets. The "no-reset" case is highlighted as more practical for current superconducting devices to avoid reset-induced noise.
- Tools: Stim for circuit simulation and sinter for threshold estimation.

3. Key Contributions

Dynamic Compass Code Definition: The introduction of a code family that combines the low-connectivity benefits of the heavy-hex lattice with the dynamic properties of Floquet codes, achieving constant-weight detectors.
Resolution of the $X$ -Basis Threshold: The paper demonstrates that the dynamic schedule restores a threshold for $X$ -basis errors, a property the standard heavy-hex code lacks.
Stability Threshold: The authors prove that the dynamic compass code possesses a threshold for stability experiments, enabling the code to fix Pauli frames during lattice surgery operations. This is a prerequisite for performing fault-tolerant logical gates.
Trade-off Characterization: The work systematically maps the trade-off between $X$ and $Z$ protection. By varying the frequency of $Z$ -measurements, one can tune the code to be more robust against specific noise biases.
Lattice Surgery Adaptation: The paper outlines how to perform lattice surgery (merging and splitting code patches) on this dynamic code, demonstrating that logical parity measurements ($XX$ and $ZZ$) can be performed with constant-weight detectors, preserving scalability.

4. Results

Threshold Existence: Numerical simulations show that while the standard heavy-hex code (Schedule A) fails to suppress logical errors in the $X$ basis as $d$ increases, the dynamic schedules (B and C) exhibit exponential suppression of logical error rates in both $X$ and $Z$ bases.
Threshold Values:
- The dynamic compass code demonstrates a stability threshold at approximately $1.3 \times 10^{-3}$ (circuit-level noise strength).
- Schedule C (which omits more $Z$ -measurements) shows a higher $X$ -basis threshold but a lower $Z$ -basis threshold compared to Schedule B.
Stability Performance:
- In stability experiments, the heavy-hex code shows no threshold (error rate increases with system size).
- The dynamic compass code shows a clear crossing point where logical error rates decrease as the number of rounds increases.
- The per-round error suppression factor for the dynamic code is significantly higher ( $\approx 2.68$ ) than the heavy-hex code ( $\approx 1.22$ , approaching 1 which implies no suppression) as patch size increases.
No-Reset vs. Reset: The "no-reset" implementation tolerates substantially higher measurement noise (approx. $2\times$ in $X$ basis, $1.3\times$ in $Z$ basis) compared to the reset implementation, making it highly suitable for current IBM hardware.

5. Significance

This work represents a significant step toward practical, large-scale quantum computing on existing hardware architectures:

Hardware Efficiency: It enables the use of the heavy-hex lattice (native to IBM's Heron and future processors) for fully fault-tolerant computation, overcoming the known scalability limitations of the static heavy-hex code.
Scalable Logic: By establishing a threshold for stability experiments, the paper provides a pathway to perform lattice surgery, the primary method for entangling logical qubits in surface-code-like architectures.
General Framework: The concept of "Dynamic Compass Codes" suggests a general design principle: one can generate families of dynamic codes from compass models by manipulating measurement schedules. This opens a new avenue for optimizing QECCs for specific hardware noise profiles (e.g., biased noise).
Experimental Validation: The authors note that this code is being implemented on an IBM Heron device (Pittsburgh), bridging the gap between theoretical simulation and experimental realization.

In summary, the paper transforms a promising but flawed hardware-native code (heavy-hex) into a fully scalable, fault-tolerant solution by leveraging dynamic measurement scheduling, thereby unlocking the potential for large-scale quantum computation on low-connectivity devices.