⚛️ quantum physics

Fast logical operations in quantum LDPC codes using simple resource states

This paper proposes a protocol for fast, joint logical measurements in quantum LDPC codes using only simple cat states and a scheduler code, achieving significant speed-ups (up to 74×) for random Clifford circuits and non-Clifford gates compared to prior complex resource state approaches.

Original authors: Mark Webster, Nicolas Delfosse

Published 2026-07-20

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Mark Webster, Nicolas Delfosse

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 doesn't use electricity, but instead uses the strange, magical rules of the quantum world. These machines, called quantum computers, promise to solve problems that would take today's supercomputers millions of years to crack. But there's a catch: quantum bits, or "qubits," are incredibly fragile. A tiny whisper of noise from the environment can scramble their information, causing the computer to crash. To fix this, scientists use "error correction," a system that spreads information across many qubits so that if one gets sick, the others can keep the patient alive.

For a long time, the standard way to do this was like building a giant, flat grid of qubits, known as a "surface code." It's reliable, but it's also incredibly wasteful. To store just a few pieces of information, you might need thousands of physical qubits, making the computer huge and expensive. Recently, scientists discovered a smarter way called "LDPC codes." Think of these as a high-efficiency packing method that can squeeze many logical qubits into a much smaller space, like folding a massive tent into a tiny backpack. However, there's a new problem: because so many qubits are packed so tightly together, it's hard to talk to just one of them without accidentally bumping into its neighbors. It's like trying to whisper a secret to one person in a crowded room where everyone is holding hands; if you try to grab one person's hand, you might pull on the whole group, slowing everything down.

This is the puzzle that Mark Webster and Nicolas Delfosse tackled in their new paper. They asked: How can we perform fast, reliable operations on these tightly packed quantum qubits without getting bogged down by the crowd?

The authors propose a clever new way to "listen" to these qubits using simple tools called "cat states." In the quantum world, a cat state is a special kind of connection where particles are linked together in a superposition, sort of like a group of friends all holding hands in a circle, waiting to see if they are all "heads" or all "tails" at the same time. Previous methods tried to build complex, custom-made structures for every single measurement, which was like building a new, elaborate bridge every time you wanted to cross a small stream. The authors realized they could just use these simple "cat state" bridges, which are much easier to build and take down.

But the real magic happens when they try to listen to many qubits at once. Imagine you have a group of 20 friends in that crowded room, and you need to know if they are all happy or sad. The old way was to ask them one by one, waiting for a clear answer from each before moving to the next. This took a long time. The authors designed a new "scheduler," which is like a smart traffic controller. Instead of asking one by one, this controller organizes a group chat where all 20 friends answer a series of questions simultaneously. The controller then uses a special decoding trick to figure out exactly what each person said, even if a few of them stumbled over their words.

In their simulations, the team tested this idea on two specific quantum codes, named Q70 and Q102. They found that when measuring 20 qubits at once, their new method was nearly three times faster than the previous best method, known as the "Viterbi" measurement. It's as if the old method took 30 minutes to get the answers, while the new method did it in just 10.

The benefits didn't stop there. By combining this fast listening technique with a new way of handling errors, they showed that complex logical operations could be sped up dramatically. For random sets of instructions (called "Clifford circuits"), the new approach was up to 74 times faster. Even for a specific, difficult type of gate called the Toffoli gate, which is crucial for many calculations, they saw a five-fold speed-up.

The paper doesn't claim to have built a working quantum computer yet; these results come from detailed computer simulations. However, the authors are confident that because their method uses simple "cat states" and doesn't require merging complex codes, it is perfectly suited for real-world quantum machines that can move their qubits around, such as those using trapped ions or neutral atoms. By making the "traffic" in these crowded quantum rooms flow much faster, this work suggests a path toward building practical, powerful quantum computers that don't need to be the size of a warehouse to do their job.

Technical Summary: Fast Logical Operations in Quantum LDPC Codes Using Simple Resource States

Problem Statement
Quantum Low-Density Parity-Check (LDPC) codes offer a significant reduction in qubit overhead for fault-tolerant quantum computation compared to surface codes due to their high encoding rates. However, a critical bottleneck exists: operating simultaneously on multiple logical qubits encoded within the same code block is challenging. Prior approaches to performing logical measurements in LDPC codes rely on complex graph-based resource states. These methods suffer from three primary limitations: (1) they require merging the memory with complex resource states, imposing stringent hardware requirements; (2) they rely on homological algebra formalisms that may be inaccessible to parts of the community; and (3) their performance is often studied only through asymptotic proofs, lacking practical investigation. Furthermore, existing cat-based measurement protocols typically focus on single logical measurements, which can be inefficient when multiple commuting operators must be measured.

Methodology
The authors propose a protocol that eliminates the need for complex resource states by utilizing only simple cat states ( $|0\dots0\rangle + |1\dots1\rangle$ ). The core innovation is the design of a scheduler code that determines the measurement sequence for $\ell$ commuting logical operators, enabling their joint decoding.

Scheduler Codes: The protocol uses an $\ell \times m$ generator matrix $G$ (the scheduler matrix) to define a measurement schedule. Each column of $G$ corresponds to a product of the target Pauli operators. The measurement outcomes form a vector $v$ , which is decoded to infer the logical outcomes $u$ .
MEDM and MECM Protocols: The authors generalize existing single-Pauli protocols to sets of commuting Paulis:
- Multi-Pauli Error Detected Measurement (MEDM): Measures $\ell$ operators using a schedule defined by $G$ . It detects errors using a check matrix $H$ (where $GH^T=0$ ). If errors are detected, the protocol restarts. A "truncated" version terminates early upon error detection to reduce average measurement time.
- Multi-Pauli Error Corrected Measurement (MECM): Uses a decoder to find the most likely logical outcome from the measurement vector $v$ . It employs a truncated version that terminates once the posterior probability of the logical outcome exceeds a threshold, minimizing the number of required measurements.
Scheduler Code Selection: To minimize the average number of measurements, the authors construct scheduler matrices of the form $G = [G_0 | G_1]$ . $G_0$ is chosen to satisfy the undetectable error rate (UER) condition with the smallest block size, ensuring early termination for error-free cases. $G_1$ is chosen to ensure the overall code distance satisfies the target logical error rate.
Logical CliNR Scheme: The authors integrate these fast measurements into a variant of the CliNR (Clifford Non-Clifford Resource) partial error correction scheme. They merge Resource State Preparation (RSP) and Resource State Verification (RSV) using the MEDM protocol and implement Resource State Injection (RSI) via physical operations (transversal CNOTs and destructive measurements) to avoid time penalties associated with logical-level injection.

Key Contributions

Simplified Resource Requirements: The protocol replaces complex graph-based resource states with simple cat states, removing the need to form merged codes and simplifying hardware requirements.
Joint Measurement of Commuting Operators: The introduction of scheduler codes allows for the efficient joint measurement of $\ell$ commuting logical operators, significantly reducing the overhead per operator compared to sequential single-Pauli measurements.
Truncated Protocols: The development of truncated MEDM and MECM protocols allows for early termination based on error detection or posterior probability, optimizing the average number of cat states consumed.
Integration with CliNR: The authors demonstrate how fast logical measurements can accelerate the CliNR scheme, specifically for preparing and verifying resource states for logical Clifford and Toffoli gates.

Results
Numerical simulations were conducted using the walking cat architecture with LDPC codes Q70 and Q102, assuming a physical error rate of $p=10^{-4}$ and a target logical error rate of $\epsilon=10^{-10}$ .

Measurement Efficiency: For measuring $\ell=20$ commuting logical operators, the proposed approach achieves a speed-up of nearly 3 $\times$ over the standard Viterbi measurement protocol. Specifically, the MECM protocol requires an average of only 1.7 cat states per logical measurement, compared to nearly 2.4 times more for the Viterbi protocol.
Logical Gate Speed-up:
- Toffoli Gates: Combining fast measurements with the new CliNR variant yields a speed-up of 4.2 $\times$ for Q70 and 5.0 $\times$ for Q102.
- Random Clifford Circuits: The speed-up is even more pronounced for random Clifford operations, reaching 18.5 $\times$ for Q70 and 74.4 $\times$ for Q102.
Stabilizer Preparation: The protocol also applies to trivial logical measurements (stabilizers), enabling fast preparation of stabilizer states.

Significance and Claims
The paper claims that this approach provides a substantial practical speed-up for logical operations in quantum LDPC codes without the hardware complexity of previous resource-state-based methods. By leveraging the ability to move qubits (as in trapped ions, neutral atoms, or spin qubits), the protocol is well-suited for near-term experimental demonstration. The authors note that the minimal space and time footprint of their logical operations makes them an ideal candidate for such demonstrations. They also highlight that while the original CliNR scheme was designed for partial error correction, their adaptation successfully reverses the typical execution time increase, achieving significant acceleration.

The authors conclude by identifying open questions for future work, including the investigation of which specific features of quantum LDPC codes ensure the independence of cat-based measurement outcomes and the design of explicit families of scheduler codes rather than relying on selecting codes with the best-known distance.

More like this