Floquet Codes: Dynamic Quantum Error Correction

Updated 8 October 2025

Floquet codes are dynamical quantum error-correcting codes defined by periodic measurements of local Pauli operators on three-colorable lattices.
They enable automatic Clifford gate processing and dynamic logical qubit manipulation through a rotating measurement schedule that mimics topological codes.
While offering hardware-friendly, low-weight checks, current planar implementations face constant code distance limitations that affect fault-tolerance scalability.

Floquet codes are dynamical quantum error-correcting codes in which the code is defined through a periodic and time-dependent measurement schedule of local Pauli operators. This approach contrasts with traditional stabilizer or subsystem codes that rely on a fixed stabilizer group. In Floquet codes, the code space—and correspondingly the instantaneous stabilizer group—evolves temporally, with the logical qubits being dynamically generated and manipulated as a function of the measurement sequence. These codes can be implemented using only low-weight (often weight-2) local measurements on three-colorable lattices, and they frequently display features such as automatic Clifford gate processing due to the dynamics of their logical operators. Floquet codes have been instantiated on a variety of lattice geometries, including planar, toroidal, and hyperbolic lattices, and further generalized to higher-dimensional and qudit-based systems.

1. Conceptual Foundations and Measurement Protocols

Floquet codes were first introduced as dynamical generalizations of subsystem codes, with a foundational example being the honeycomb code defined on a three-valent, three-face-colorable lattice (Vuillot, 2021). In a typical 2D Floquet code, physical qubits are placed on the vertices of, for instance, a honeycomb lattice, and each edge of the lattice is assigned a color corresponding to a specific Pauli operator (e.g., X for red, Y for green, Z for blue). The measurement protocol consists of a cyclic, periodic schedule in which only weight-2 gauge checks associated with these colored edges are measured. For the honeycomb code, the schedule proceeds as:

Measure all red (X⊗X) edges,
Then blue (Z⊗Z) edges,
Then green (Y⊗Y) edges,
and repeat cyclically.

This measurement schedule induces an “instantaneous stabilizer group” (ISG) at every round, which is Clifford-equivalent to the stabilizer group of a 2D homological/topological code such as the surface code. Although the underlying system has no logical qubits if all gauge checks were measured simultaneously, the temporal structure of measurement ensures that certain logical operators are never fully projected out, effectively creating a room for k logical qubits.

In more general constructions (e.g., color code lattices, hyperbolic tilings (Higgott et al., 2023, Fahimniya et al., 2023, Ozawa et al., 28 Sep 2025), or qudit extensions (Tanggara et al., 2 Oct 2024)), the code is defined similarly with periodic measurement of local two-body operators on a three-colorable lattice, ensuring that the ISG always encodes a (topology-determined) set of logical qubits.

2. Subsystem Code Structure and Logical Operators

Floquet codes can be understood as time-dependent subsystem codes where the gauge group is generated by the set of two-qubit checks. For the honeycomb/historic Floquet code:

The gauge checks $\{P_e\}$ are given by $P_e = P^{C(e)}_{v_1}P^{C(e)}_{v_2}$ , where $C(e)$ is the color of edge $e$ and $v_1, v_2$ its vertices.
The stabilizer group (at each time step, i.e., the ISG) is built as products over faces or cycles, corresponding to topologically nontrivial loops in the lattice.
Logical operators correspond to non-contractible cycles that are not completely fixed by the periodically measured checks. Their support and type (e.g., X- or Z-type) dynamically “rotate” under the measurement cycle, a process that can implement Clifford logical gates (for instance, a Hadamard every Floquet period).
The number of encoded logical qubits $k$ is determined topologically, e.g., for a closed orientable surface,

$k = 2g$

where $g$ is the genus, or $k=g$ for non-orientable surfaces (Vuillot, 2021).

This subsystem approach generalizes to non-CSS Floquet codes, CSS variants (Davydova et al., 2022), and constructions without a parent subsystem description (dynamic tree codes).

3. Boundary Conditions, Rotation of Logical Operators, and Fault-Tolerance

A distinct feature of planar Floquet codes is the treatment of boundaries and the resulting dynamics of logical operators. By introducing boundaries (through the removal of certain faces) and maintaining colored, odd-length edges at the boundary, the ISGs are manipulated such that they imitate surface code patches with alternately “smooth” and “rough” boundaries, which rotate in position every Floquet cycle (Vuillot, 2021). The logical operators themselves undergo a “caterpillar”-like motion:

After each cycle, logical operators translate and change type (e.g., an $X$ -type boundary operator may become $Z$ -type), corresponding to logical Clifford transformations such as Hadamard gates.
This built-in logical gate generation is a central operational benefit of the Floquet approach.

However, this rotating dynamics also implies that the code distance—the minimal weight of an undetectable logical operator—is constant in system size. That is, regardless of the size of the lattice patch, there exist constant-size space-time error paths (error sheets in the syndrome graph) that result in a logical error. As such, planar Floquet codes in the presented construction do not exhibit exponential suppression of logical error with code size and are not fault-tolerant under standard definitions.

4. Gauge Checks, ISG Evolution, and Measurement Scheduling

The evolution of the ISG under the measurement schedule is central to the dynamical error correction properties of Floquet codes:

The code alternates which type of two-qubit gauge check is measured in each subround.
Each ISG at a round is constructed from face (or cycle) stabilizers corresponding to the last measured basis, with information about previous checks entering via products or “history” operators.
In practice, this means a schedule of the form:
1. Measure all checks of type A (e.g., red edges/XX)
2. Update ISG to include A-type face stabilizers.
3. Measure type B (e.g., blue/ZZ), update ISG, etc.
The cyclical timing ensures that homologically nontrivial loop operators are never all simultaneously projected onto, leaving the logical space open at all times.
In patches with well-chosen boundary conditions (e.g., hexagons with three-color alternating perimeter), the code effectively encodes logical qubits.

Formal relationships include:

Number of logical qubits (closed surface): $k = 2g$ (orientable genus $g$ ), $n_s = n_f - 1 + k$ (ISG dimension with $n_f$ faces).
Space-time diagrams illuminate how error propagation and logical operator motion occur.

5. Limitations, Trade-offs, and Implications for Fault-Tolerance

The principal limitation of planar Floquet codes as constructed in (Vuillot, 2021) is the presence of constant-distance logical operators. As a result:

Logical errors can be realized via constant-size operators in a finite time, independent of the code size.
Logical error rates thus do not decrease exponentially with system size, contrary to the threshold behavior typical in (distance-growing) topological codes.
While the dynamical rotation of logical operators supports built-in Clifford processing and the use of only local, weight-2 measurements, the insufficient scaling of code distance prevents the protocol as presented from being a fully scalable, fault-tolerant quantum memory.
The work emphasizes the need for alternative strategies—such as different boundary designs or higher-dimensional analogues—to overcome these fundamental trade-offs.

A possible implication is that further advances in boundary engineering or generalization to three-dimensional manifolds may provide a pathway to fault-tolerant, scalable Floquet codes with distance growing in system size.

The “planar Floquet code” construction captures the essential features of one branch of the Floquet code paradigm, particularly as a dynamical subsystem code leveraging the honeycomb lattice. It sets the groundwork for:

Generalizations to codes defined on other three-colorable lattices and with different commutation structures.
Extensions into CSS Floquet codes, dynamic tree codes, and 3D fracton-like Floquet codes, each offering various trade-offs between locality, measurement simplicity, rate, and distance (Davydova et al., 2022, Zhang et al., 2022).
Practical advances in hardware compatibility, with codes utilizing only two-qubit measurements and native to platforms such as Majorana-based architectures (Paetznick et al., 2022).
Active research on decoding, syndrome extraction, and optimizing performance in the presence of experimental constraints and hardware imperfections.

This construction, while not fault-tolerant as a planar code, highlights the conceptual possibilities unlocked by dynamically generated code spaces and remains a key reference in the ongoing development of dynamical and measurement-based quantum error correction.