⚛️ quantum physics

Floquetifying stabiliser codes with distance-preserving rewrites

This paper introduces a ZX-calculus-based Floquetification procedure that transforms arbitrary stabilizer codes into fault-tolerant versions using only single- and two-qubit operations while provably preserving the original code's distance and logical qubit count through the novel application of distance-preserving rewrites.

Original authors: Benjamin Rodatz, Boldizsár Poór, Aleks Kissinger

Published 2026-07-17

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Benjamin Rodatz, Boldizsár Poór, Aleks Kissinger

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 castle out of glass. It's a beautiful idea, but glass is fragile; a single sneeze or a tiny vibration can shatter a whole tower. This is the daily struggle of quantum computing. The "glass" here is the quantum bit, or qubit, which holds information in a delicate state of being both 0 and 1 at the same time. The "sneezes" are noise and errors from the environment. To stop the castle from crumbling, scientists use "quantum error correction," a system that spreads the information of one qubit across many others, like building a tower out of many small, interlocking glass shards so that if one breaks, the whole thing doesn't fall.

The most common way to do this is with "stabiliser codes." Think of these as a set of strict rules or measurements you constantly check to make sure the glass shards are still in the right place. Usually, these rules involve checking many shards at once (a "high-weight" measurement). But here's the problem: checking ten shards at once is like trying to juggle ten glass balls while standing on a wobbly ladder. It's incredibly hard to do without dropping something. If the measurement itself is too complex, it might introduce more errors than it fixes. So, the big question for researchers is: How can we check these rules using only simple, safe moves—like checking just one or two shards at a time—without losing the protection of the whole castle?

This is exactly what the paper by Benjamin Rodatz, Boldizsár Poór, and Aleks Kissinger tackles. They have developed a clever "translation" method that takes these complex, hard-to-build quantum codes and rewrites them into simpler, easier-to-build versions. They call this process "Floquetifying."

Here is the magic trick: Imagine you have a giant, complicated recipe for a cake that requires mixing ten ingredients in a single bowl at the exact same time. It's messy and risky. The authors found a way to rewrite that recipe so you can still make the exact same cake, but now you only need to mix two ingredients at a time, one after another. The final cake tastes identical, and the structure is just as strong, but the kitchen is much safer and easier to manage.

In the world of quantum physics, this "recipe rewriting" is done using a visual language called ZX calculus. You can think of ZX calculus as a set of colorful, connect-the-dot puzzles that represent quantum circuits. The authors realized that while you can usually rearrange these puzzles to make them simpler, doing so often breaks the "distance" of the code. In our glass castle analogy, "distance" is how far a single sneeze has to travel to knock the whole tower down. A high distance means the castle is very sturdy; a low distance means it's fragile.

The authors' major breakthrough is defining a special set of "safe moves" for these puzzles. They call these "distance-preserving rewrites." It's like having a rulebook that says, "You can move these blocks around, but you are strictly forbidden from making a move that would let a single sneeze knock down two walls at once." By sticking to these safe moves, they proved that they can break down any complex measurement (checking many qubits) into a sequence of simple, single- or double-qubit checks.

The result is a new type of quantum code called a "Floquet code." These codes are dynamic; instead of checking the rules all at once, they check them in a specific, repeating rhythm. The authors showed that for any existing quantum code, you can create a Floquet version that uses only simple, two-qubit operations. Crucially, they proved that this new code is just as strong as the old one. It keeps the same number of "logical" qubits (the actual information you want to store) and the same "distance" (the same level of protection against errors).

There is a small cost to this simplicity, though. To perform these complex checks using only simple steps, the new code needs a few extra "helper" qubits. The authors calculated that the number of extra helpers needed grows linearly with the size of the original complex measurement. If the original code checked 100 qubits at once, the new code might need about 50 extra helpers to do the job in small steps. But for many modern codes, this overhead is manageable and constant.

Perhaps the most exciting part is that these new codes aren't just "simpler versions" of the old ones; they are a different beast entirely. The authors show that these new codes are "proper" Floquet codes, meaning they have a dynamic structure that changes over time, unlike the static rules of traditional codes. This opens the door to building quantum computers that are much more practical, using hardware that can only handle simple, local connections, while still keeping the data safe from the chaotic noise of the real world. They didn't just suggest this might work; they provided a mathematical proof that the safety guarantees hold true, turning a difficult engineering problem into a solvable puzzle.

Problem Statement
Stabiliser codes are the primary class of quantum error-correcting codes, defined by commuting Pauli measurements. However, implementing these codes fault-tolerantly is challenging when the stabiliser measurements have high weight (involving many qubits), as high-weight operations are difficult to realize on near-term hardware. While "Floquet codes" offer a dynamic alternative using time-dependent, non-commuting measurements, existing methods to convert stabiliser codes into Floquet codes with low-weight operations (specifically single- and two-qubit operations) have been limited. A significant hurdle in using graphical languages like the ZX calculus for this conversion is that standard rewrite rules generally do not preserve the code distance, potentially rendering the resulting code less robust against errors.

Methodology
The authors propose a "Floquetification" procedure that transforms an arbitrary stabiliser code into a Floquet code using only single- and two-qubit operations while preserving the original code's distance and number of logical qubits. The methodology relies on three core components:

ZX Calculus Framework: The measurement circuits of stabiliser codes are represented as ZX diagrams. The authors utilize the Clifford fragment of the ZX calculus, which is complete for stabiliser quantum mechanics.
Distance-Preserving Rewrites: To address the issue that standard ZX rewrites can reduce code distance, the authors define a new class of "distance-preserving rewrites." A rewrite is distance-preserving if, for any diagram context, replacing a sub-diagram with its rewritten equivalent does not decrease the minimum weight of non-trivial, undetectable errors. They prove that specific rewrites (such as fusing spiders and decomposing high-degree spiders into lower-degree ones) satisfy this condition.
Measurement-Circuit (MC) Flow: The authors introduce a structural property called "measurement-circuit flow" on ZX diagrams. This flow, defined by a partial order and a set of directed paths, guarantees that a diagram can be extracted into a quantum circuit consisting of local Cliffords and Pauli measurements (MCLC form). They demonstrate that any diagram with MC flow can be transformed into a "well-covered" form with spiders of degree at most three using only distance-preserving rewrites.

The procedure involves:

Expressing the original stabiliser code's measurement schedule as a ZX diagram.
Decomposing arbitrary-weight Pauli measurements into equivalent circuits of single- and two-qubit operations using distance-preserving rewrites. This decomposition introduces auxiliary qubits but ensures that a single error in the new circuit creates at most a single error on the data qubits.
Composing these decomposed measurements and removing mid-circuit state preparations and destructive measurements to form a dynamical circuit.
Extracting the final Floquet code, which consists of an infinitely repeating schedule of Pauli measurements.

Key Contributions

Distance-Preserving Rewrites: The paper defines and proves the validity of a family of ZX rewrites that guarantee the preservation of ZX distance (and thus code distance) during circuit manipulation. This allows for the safe transformation of error-correcting codes without degrading their error-detection capabilities.
Generalized Floquetification: The authors generalize the Floquetification procedure (previously applied to specific codes) to arbitrary stabiliser codes. They provide an algorithm to synthesize a new Floquet code from any given stabiliser code.
Resource Overhead Analysis: The paper quantifies the overhead of the procedure. The number of additional physical qubits required is linear in the weight of the largest measurement in the original code, specifically bounded by $\lceil w/2 \rceil + \log_2 w$ , where $w$ is the maximum weight.
Preservation of Logical Properties: The procedure provably preserves both the code distance ( $d$ ) and the number of encoded logical qubits ( $k$ ) of the original stabiliser code.
Proper Floquet Codes: The authors show that the resulting codes are "proper" Floquet codes (distinct from stabiliser or subsystem codes) because they contain non-commuting measurements and, under specific scheduling, the associated subsystem code has no logical qubits.

Results

The authors demonstrate the procedure on the $[[4, 2, 2]]$ stabiliser code, transforming it into a $[[6, 2, 2]]$ Floquet code using only weight-1 and weight-2 measurements.
They provide a general decomposition for Pauli measurements of weight $w$ , showing that they can be implemented using at most $w + \lceil w/2 \rceil + \log_2 w$ qubits.
Theoretical proofs confirm that the resulting Floquet code maintains the same distance and number of logicals as the input stabiliser code.
The procedure ensures that single, undetectable errors in the decomposed measurement circuits result in at most a single error on the data qubits, maintaining fault tolerance.

Significance
The paper claims to provide a mathematical foundation for reasoning about quantum circuits in noisy settings using the ZX calculus. By introducing distance-preserving rewrites, the authors enable the compilation of stabiliser codes into forms compatible with hardware constraints (limited to low-weight operations) without sacrificing error-correcting performance. This offers a dynamic perspective on stabiliser codes, allowing for the design of Floquet codes that may outperform comparable stabiliser codes in specific architectures or implement logical Clifford gates fault-tolerantly at no extra cost. The work suggests that distance-preserving rewrites could be extended to broader fault-tolerant circuit synthesis, optimization, and verification tasks.

More like this