⚛️ quantum physics

Foliated Quantum Error Correction for Qudits

This paper introduces a framework for foliating Pauli-based quantum error-correcting codes over prime-dimensional qudits to enable fault-tolerant measurement-based quantum computing, demonstrating its applicability to various code families and showing that the resulting foliated qudit toric code achieves error thresholds comparable to its non-foliated counterpart.

Original authors: Gözde Üstün, Simon J. Devitt, Jason Saied

Published 2026-07-16

📖 4 min read🧠 Deep dive

CC BY 4.0

Original authors: Gözde Üstün, Simon J. Devitt, Jason Saied

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 beautiful, but if you drop a single pebble, the whole thing might shatter. This is the current state of quantum computing: we have these incredibly powerful machines that can solve problems no supercomputer ever could, but they are made of "glass" that breaks easily when the slightest bit of noise or heat hits them. To fix this, scientists use a trick called Quantum Error Correction. Think of it like weaving a safety net. Instead of storing a piece of information on one fragile glass shard, you spread it out across a giant, woven net. If one part of the net breaks, the pattern of the whole net tells you exactly where the break happened so you can fix it without losing the treasure inside.

Now, imagine that instead of using simple, two-sided coins (like heads or tails) to build your net, you have access to spinning tops that can land on any number from 1 to a million. These are called qudits (quantum digits). In many real-world machines, like those using light particles (photons), these high-dimensional tops are actually easier to make than simple coins. However, figuring out how to weave a safety net out of these complex spinning tops has been a puzzle. The big question is: Can we take the complex, high-dimensional spinning tops and arrange them into a giant, fault-tolerant net that can survive mistakes, just like the simpler coin-based nets do?

This is exactly what the researchers in this paper set out to do. They have built a new "instruction manual" for weaving these high-dimensional safety nets. They call their method Foliated Quantum Error Correction. To understand "foliation," imagine a stack of pancakes. In the old way of doing things, you might try to build a 3D tower of glass blocks all at once, which is incredibly hard. This new method suggests building the tower one pancake layer at a time. You prepare a flat sheet of entangled spinning tops, measure them to fix errors, and then "teleport" the information to the next sheet, and the next, creating a 3D structure out of 2D layers. This is perfect for light-based computers because light doesn't like to stick around and interact; it's much easier to make a sheet, measure it, and move on to the next one.

The team showed that this "pancake stack" method works for almost any type of quantum code built with prime-numbered spinning tops. They didn't just guess; they simulated the process on a computer to see how well it holds up. They tested it on three different types of nets: a famous grid-like net called the toric code, a tiny but perfect five-piece net called the [[5, 1, 3]] code, and a dynamic net that changes its pattern over time called the honeycomb code.

The results were promising. In their simulations, the high-dimensional nets were able to withstand errors just as well as, and sometimes even better than, the simpler coin-based nets. For example, when they tested the toric code with spinning tops that had 3 possible states, the net could survive an error rate of about 0.023 (roughly 2.3%). But when they increased the complexity to spinning tops with 7,919 possible states, the net became much tougher, surviving error rates up to 0.088 (nearly 9%). This suggests that the more complex the spinning top, the stronger the safety net becomes, at least in these computer simulations.

The paper also points out that you don't need to build the entire giant tower of pancakes before you start. You only need to keep a few layers in memory at a time, measure them, and then build the next ones as you go. This is a huge deal for light-based computers, where it's hard to make everything connect at once. Instead, you can build small, uniform pieces and stitch them together as needed, much like a construction crew laying bricks one by one rather than trying to drop a whole wall into place.

In short, this paper provides a blueprint for turning the complex, high-dimensional spinning tops found in light-based quantum computers into robust, error-correcting machines. By stacking them in layers and measuring them step-by-step, the researchers have shown a path toward building quantum computers that are both powerful and tough enough to survive the messy real world. While these numbers come from simulations and real-world experiments will be the ultimate test, the math suggests that using these high-dimensional tops could be the key to unlocking the full potential of quantum computing.

Technical Summary: Foliated Quantum Error Correction for Qudits

Problem Statement
Measurement-based quantum computing (MBQC) is a paradigm where computation is performed on a pre-prepared graph state via single-qubit (or qudit) measurements. While fault-tolerant MBQC is well-established for qubits (e.g., Raussendorf's 3D cluster state foliating the surface code), extending these fault-tolerant protocols to higher-dimensional systems (qudits) remains an open challenge. Although qudit codes theoretically offer higher error-correction thresholds, practical implementation is hindered by complex noise models and control challenges in many physical platforms. However, in photonic systems, high-dimensional states are readily available, and the dominant noise mechanism (photon loss) is dimension-independent. This creates a specific motivation to develop fault-tolerant MBQC protocols for prime-dimensional qudits to leverage these potential threshold advantages.

Methodology
The authors present a general framework for "foliating" any Pauli-based quantum error-correcting code defined over prime-dimensional qudits ( $d$ ). The construction generalizes previous work on qubit CSS and non-CSS codes to the qudit setting, including dynamical codes.

Graph State Construction: The framework defines a qudit graph state $\Lambda$ indexed by 3-tuples $(type, label, time)$.
- Data Qudits: Represented as nodes $(0, q, t)$ , forming linear chains where adjacent time steps are connected by edges with weights $(-1)^t$ .
- Ancilla Qudits: Represented as nodes $(1, c, t)$ , corresponding to syndrome checks at time $t$ .
- Entanglement: Ancillas are entangled with data qudits via Controlled-Z ($CZ$) gates with weights determined by the code's parity check matrix $H(t)$ . For CSS codes, ancillas at even/odd time steps connect to $Z$ -type/ $X$ -type data qudits respectively. For non-CSS codes, additional edges and modified measurement bases are required to preserve commutativity.
Foliation and Detectors:
- The protocol involves preparing the graph state and performing $X$ -basis measurements on all qudits (except initial/final boundary conditions).
- Detectors: To enable error correction, the authors define "detectors" as stabilizers of the graph state that commute with all measurements. A detector $D(c, t)$ is constructed by taking the product of an ancilla measurement at time $t$ , the inverse of the same ancilla measurement at time $t+2$ , and the data qudit measurements in the intervening time step $t+1$ , weighted by the check matrix entries.
- Error Correction: In the presence of errors, these detectors fail to stabilize the post-measurement state. The authors demonstrate that under a phenomenological noise model (Pauli $Z$ errors on the graph state), the error correction problem maps directly to the circuit-based implementation of the code.
Generalization: The framework accommodates:
- CSS Codes: Stabilizer and subsystem codes where checks are purely $X$ or $Z$ .
- Non-CSS Codes: Codes with mixed $X$ and $Z$ checks (e.g., the $[[5,1,3]]$ code), requiring specific edge weights between ancillas and modified measurement bases ( $XZ^{-p_X p_Z}$ ).
- Dynamical Codes: Codes where the set of measured checks changes over time (e.g., Floquet codes), requiring detectors that span multiple time steps.

Key Contributions

General Framework: A constructive definition for foliating arbitrary Pauli-based qudit codes (stabilizer, subsystem, and dynamical) into a measurement-based graph state.
Non-CSS and Dynamical Extension: The first explicit construction for foliating non-CSS qudit codes and dynamical qudit codes (specifically generalizing the honeycomb code).
Numerical Validation: The authors numerically simulate the foliated qudit toric code using a Hard-Decisions Renormalization Group (HDRG) decoder. They calculate error thresholds for various dimensions $d$ .
Threshold Analysis: The simulations show that the error-correction threshold increases with the qudit dimension $d$ . For example, the threshold rises from $\approx 0.023$ for $d=3$ to $\approx 0.088$ for $d=7919$ . These values are comparable to or exceed those of non-foliated circuit-based versions.

Results

Toric Code: The foliated qudit toric code was simulated under Pauli $Z$ noise. The results confirm that the foliated construction maintains fault tolerance with thresholds that scale favorably with dimension. The authors note that the observed thresholds are higher than previous circuit-based results, attributing this partly to the use of a rotated toric code and a modified minimum-weight spanning tree strategy in the decoder.
Perfect Code: The framework was successfully applied to the qudit $[[5,1,3]]$ perfect code (a non-CSS example), demonstrating the ability to handle mixed checks and inter-ancilla entanglement.
Honeycomb Code: A qudit generalization of the CSS honeycomb code was constructed, illustrating the foliation of a dynamical code where detectors span multiple time steps (e.g., from $t=0$ to $t=4$ ).

Significance and Claims
The paper claims to provide a foundational framework for fault-tolerant MBQC in high-dimensional systems. The significance lies in:

Platform Relevance: It directly addresses the needs of photonic platforms where high-dimensional states are native and measurement-based protocols are natural.
Theoretical Unification: It unifies the foliation of stabilizer, subsystem, and dynamical codes under a single graph-state construction for qudits.
Practical Feasibility: The authors argue that full graph state construction is not required; only 2–3 layers need to be held in memory at a time, with subsequent layers generated on demand. This aligns with fusion-based quantum computing (FBQC) strategies, suggesting a path toward resource-efficient implementation in photonic systems.

The work does not claim to have experimentally realized these codes but provides the theoretical construction and numerical evidence necessary to motivate their implementation in future photonic architectures.

Technical Summary: Foliated Quantum Error Correction for Qudits

More like this