Quantum Error Correction Meets ZX-Calculus

To achieve the transformational use cases of quantum computers, quantum error correction (QEC) must be used to protect delicate quantum information by encoding logical quantum bits across many physical qubits. Fault-tolerant logical gates are then used to process the encoded information reliably and execute quantum algorithms. This, however, comes with a large resource overhead. To this end, extensive research has been carried out to study QEC and optimise fault-tolerant quantum computation.

The ZX-calculus is a graphical language for reasoning about quantum computations. It can express computations in different models, such as quantum circuits or the one-way model. It is complete, in the sense that any true equality between diagrams can be derived entirely graphically. Over the past decade, the ZX-calculus has been used to optimise quantum computations and map logical circuits to hardware architectures.

Initial steps have already been taken in applying ZX-calculus to quantum error correction and fault tolerance, but the two communities thus far have remained mostly separate. In this Dagstuhl Seminar 25382 “Quantum Error Correction Meets ZX-Calculus”, we share knowledge and foster collaboration between experts from both communities. Below lists the main topics that have been discussed.

The ZX-calculus and mainstream fault-tolerant quantum computation:

How do ZX-based methods compare to and/or complement the techniques and representations used in the larger community to study diverse quantum error-correcting codes such as colour codes, Floquet codes, bicycle codes, and quantum low-density parity check codes? How can the ZX-calculus be used to improve fault-tolerant quantum compilation and help solve open problems in developing quantum error-correcting codes? For example, can we use the ZX-calculus to analyze various fault-tolerant protocols, design more efficient fault-tolerant compilation strategies, and connect different frameworks for dynamical codes?

Quantum error correction beyond static codes:

Building on recent work about Floquet codes and the spacetime frameworks for QEC, as well as insights from measurement-based quantum computing, what dynamical protocols can we develop that go beyond the state-of-the-art? For example, can we optimise Floquetification procedures with respect to qubit and gate count, qubit connectivity, and number of measurement cycles?

The ZX-calculus and error correction beyond qubits:

Error-correcting codes based on qudits or bosons have advantages over standard qubit-based codes. What new protocols for quantum error-correcting codes can we develop by leveraging the ZX-calculi for qudits or bosonic modes as a unified language? For example, can we use the ZX-calculus for bosonic modes to derive improved protocols for preparing resource states such as Gottesman-Kitaev-Preskill states and cluster state fragments?

By bringing together researchers and industry practitioners to discuss these challenges in small groups, our aim was to bridge the ZX-calculus and QEC communities and foster collaborative efforts toward advancing fault-tolerant quantum computation. Several groups generated promising insights and ideas with the potential to develop into strong projects, and we look forward to seeing how these unfold in the coming years.

This Dagstuhl Seminar 25382 “Quantum Error Correction Meets ZX-Calculus” brought together researchers from quantum error correction, ZX calculus, and fault-tolerant quantum computing (FTQC) to explore new synergies between graph-theoretical methods and emerging FTQC frameworks. Over the course of five days, the program combined tutorials, structured discussions, and collaborative breakout sessions to develop shared understanding and identify promising research directions.

The seminar opened with in-depth tutorials on quantum error correction through the lens of ZX-calculus and on error detection in Clifford protocols, establishing a common technical foundation for participants. Subsequent sessions expanded the scope to higher-dimensional quantum systems, fault-tolerance-by-construction techniques, and decoding approaches for qLDPC codes. These tutorials sparked active discussions and shaped the formation of working groups.

A central component of the seminar was the daily cycle of brainstorming, progress reporting, and regrouping. Participants identified key open questions, self-organized into focused teams, and iteratively refined problem statements across the week. This structure fostered cross-disciplinary collaboration, allowing ideas developed in earlier tutorials to inform concrete research tasks. Group activities, including a mid-week hike, further strengthened informal communication and collaboration within the community.

By the end of the seminar, the working groups had narrowed down several directions for ongoing research, including improved interfaces between ZX-based reasoning and error-correction formalisms, as well as methodologies for constructing fault-tolerant protocols via compositional or automated tools. The momentum built during the seminar is expected to carry forward, fostering collaboration between previously separate research areas and supporting the development of future joint projects.

We explore a unified framework for fault-tolerant quantum computation by combining graph-theoretic formalisms with error-correcting code constructions. First, building on the one-to-one correspondence between the phase-free ZX diagrams and Calderbank–Shor–Steane (CSS) codes, we give a fully graphical description of stabiliser states and various code transformation protocols such as lattice surgery and code switching.

Second, we extend ZX-calculus with a refined set of rewrite rules that preserve not only the semantics of the underlying linear maps, but also the diagram’s behaviour under noise. As a result, we can tranform ZX diagrams while preserving how errors propagate through them. Fault-tolerant synthesis steps, such as those used in syndrome extraction and state preparation, can therefore be performed directly on ZX diagrams. This provides a unified, correct-by-construction approach to reasoning about and compiling fault-tolerant quantum computations at the diagrammatic level.

A systematic understanding of error detection and correction within quantum circuits is essential to develop scalable and reliable quantum computing architectures. In this tutorial, I gave an introduction into a circuit-centered perspective on active quantum error-correction in Clifford circuits. After motivating the problem of protecting information with active measurement dynamics, I started with a short introduction into the stabiliser formalism, the main technical tool to study the effect of errors in Clifford circuits.

The center of the tutorial was the decoding problem: Given an error model in a Clifford circuit we can rigorously define a classical decoding problem based on certain combinations of measurement outcomes in the circuit. The main method used in the presentation was a diagramatic representation of measurement circuits, in particular the ZX calculus. Using ZX rewrites and Pauli symmetries of the tensors appearing in a Clifford circuit, we can deduce linear constraints on the measurement outcomes that are used for decoding. This naturally defines the concept of a fault-distance, which captures elementary properties of a circuit to be able to correct for errors up to a given weight.

At the end, I sketched how to incorporate logically non-trivial operations into the framework without resorting to a fixed input encoding but focussing on a protocol-first perspective.

A key challenge in fault-tolerant quantum computing is synthesising and optimising circuits in a noisy environment, as traditional techniques often fail to account for the effect of noise on circuits. In this work, we propose a framework for designing fault-tolerant quantum circuits that are correct by construction. The framework starts with idealised specifications of fault-tolerant gadgets and refines them using provably sound basic transformations.

To reason about manipulating circuits while preserving their error correction properties, we define fault equivalence; two circuits are considered fault-equivalent if all undetectable faults on one circuit have a corresponding fault on the other. This guarantees that the effect of undetectable faults on both circuits is the same. We argue that fault equivalence is a concept that is already implicitly present in the literature. Many problems, such as state preparation and syndrome extraction, can be naturally expressed as finding an implementable circuit that is fault-equivalent to an idealised specification.

To utilize fault equivalence in a computationally tractable manner, we adapt the ZX calculus, a diagrammatic language for quantum computing. We restrict its rewrite system to not only preserve the underlying linear map but also fault equivalence, i.e. the circuit’s behaviour under noise. Enabled by our framework, we verify, optimise and synthesise new and efficient circuits for syndrome extraction and cat state preparation. We confirm the improved performance of our optimised circuits in simulation. We anticipate that fault equivalence can capture and unify different approaches in faulttolerant quantum computing, paving the way for an end-to-end circuit compilation framework.

We introduced the Gridsynth algorithm, which solves the problem of approximate synthesis for single-qubit Clifford+$T$ operators. There are three main ingredients to this algorithm: solving a lattice grid problem, solving a Diophantine equation, and exact synthesis.

We started by talking about the classic Diophantine equation $a^2+b^2=n$, which Fermat solved in 1640. It turns out that there is a very efficient algorithm which inputs $n$, and either outputs an integer solution $(a,b)$ or determines that no such solution exists, provided that we can factor $n$. Also, the above equation is equivalent to $t{t}^{†}=n$, where $t=a+ib\in \mathbb{Z}[i]$ is a Gaussian integer. It turns out that the same algorithm can also be used to solve the equation $t{t}^{†}=\xi$, where $\xi \in \mathbb{Z}[\sqrt{2}]$ is given and $t\in \mathbb{Z}[\omega ]$ is unknown. Here $\omega =e^{\pi /4}$ is an 8th root of unity.

The second ingredient to the approximate synthesis algorithm is lattice grid problems. Given a convex subset $C\subseteq {ℝ}^k$, the problem is to enumerate all points of $C$ that have integer coordinates. The LLL algorithm can solve this problem efficiently, provided that the dimension $k$ is fixed and small.

The third ingredient is exact synthesis. Given a unitary $2\times 2$-operator $U$, it is a theorem by Kliuchnikov, Maslov, and Mosca that $U$ can be exactly represented over the Clifford+$T$ gate set if and only if the matrix entries of $U$ are in the ring $\mathbb{Z}[\frac{1}{2},\omega ]$. Moreover, the $T$-count of the resulting word can be predicted from the largest power ${\sqrt{2}}^k$ appearing in the denominator of the matrix entries.

Putting these ingredients together, we can an efficient algorithm for approximate synthesis. Given a unitary $z$-rotation , our goal is to find an operator approximating it to within $ϵ$. This can be done by first choosing $u\in \mathbb{Z}[\frac{1}{2},\omega ]$ to lie within a certain convex region of the complex numbers, and such that $u^{\bullet }$ is in the unit circle. This turns out to be a lattice grid problem. Next, we must find $t\in \mathbb{Z}[\frac{1}{2},\omega ]$ such that $u{u}^{†}+t{t}^{†}=1$. This is a Diophantine equation. Finally, one uses exact synthesis to turn the resulting operator into a word over the generators. We saw a demo of the algorithm that approximated a $z$-rotation by angle $47$ degrees up to $ϵ={10}^{-100}$ in less than a second.

We formally define homological quantum rotor codes which use multiple quantum rotors to encode logical information. These codes generalize homological or CSS quantum codes for qubits or qudits, as well as linear oscillator codes which encode logical oscillators. Unlike for qubits or oscillators, homological quantum rotor codes allow one to encode both logical rotors and logical qudits in the same block of code, depending on the homology of the underlying chain complex. In particular, a code based on the chain complex obtained from tessellating the real projective plane or a Möbius strip encodes a qubit. We discuss the distance scaling for such codes which can be more subtle than in the qubit case due to the concept of logical operator spreading by continuous stabilizer phase-shifts. We give constructions of homological quantum rotor codes based on 2D and 3D manifolds as well as products of chain complexes. Superconducting devices being composed of islands with integer Cooper pair charges could form a natural hardware platform for realizing these codes: we show that the 0-$\pi$-qubit as well as Kitaev’s current-mirror qubit – also known as the Möbius strip qubit – are indeed small examples of such codes and discuss possible extensions.

Graphs can be used to express stabiliser error-correcting codes. Graphs from graph states give rise to natural stabilisers for these codes, associated locally with the graph’s vertices. Using a greedy decoding algorithm, it can be shown that this algorithm cannot go wrong when there are few enough errors. Furthermore, the algorithm performs better if the graphs satisfy certain conditions, such as having no short cycles. This gives a generic way to get distance lower bounds for constructed codes without using topological arguments.

For certain codes, it is ok to design syndrome extraction circuits in ways that are not, in themselves, fault-tolerant, i.e. single errors in measurement circuits can propagate out to multiple errors on data qubits. However, if these “hook errors” are perpendicular to logical operators, they don’t necessarily decrease the code distance. Previously, we didn’t know how to think about this graphically, but we seem to have come up with a new technique, which is called quantum acupuncture. It can add certain fault gadgets using fault-equivalent rewrites and rigorously prove that these “ok” syndrome extraction circuits really are ok. This might work for a broader class of codes than previously considered.

We investigated equivalences/mappings between noise model representations in ZX-calculus, focusing in particular on coarse-graining techniques and fault-bounded rewrites. Our aim was to develop well-defined transformations that convert physically motivated noise models into forms that are easier to understand and simulate, where relative accuracy can be reliably understood.

Some recent work by two members of the seminar (Arthur Pesah and Michael Vasmer) showed that two circuits can be shown to be “equivalent” in terms of fault-tolerance by modelling them as chain complexes, and mapping one into the other using chain maps. They found some elementary chain maps from which many circuit equivalences can be shown. In parallel, some other members of the seminar (Ben Rodatz and Julio Magdalena de la Fuente) have worked on circuit equivalences using distance-preserving rewrite rules in ZX calculus and tensor networks. The question has then emerged on whether those two frameworks are equivalent. All the authors of those ideas, along with other members of the seminar, have discussed how to bridge the two formalisms. They have made progress on establishing the exact connection between the two (i.e., ZX diagrams can be associated to a chain complex and rewrite rules as chain maps) and discussed the path towards fully bridging the two (i.e., finding how all the elementary ZX rules are described in terms of chain maps, and how idealization of edges is described in the chain complex formalism).

Fault equivalence is a novel and recently defined relationship between quantum circuits under noise. It formalises when the behaviour of two noisy circuits can be considered the same, and therefore when they can be interchanged. This concept captures and formalises many ideas found in the literature on fault-tolerant quantum computing. While checking fault equivalence is generally NP-hard, the ZX calculus offers a way to efficiently manipulate quantum circuits while preserving fault equivalence.

Throughout this week, we have explored various aspects of fault equivalence and its role in fault-tolerant quantum computing. These discussions included formalising existing notions – such as Gottesman’s fault tolerance conditions – in terms of fault equivalence, as well as examining the decoding problem under fault-equivalent rewrites and reasoning locally about hook errors using fault equivalence.

We discussed two types of decoding. Joschka Roffe gave a tutorial on how Belief Propagation (BP) decoding works. He showed an example of BP decoding of the classical repetition code. Messages get passed from checks to bits and from bits to checks, each message containing a belief that is used to update the estimated probability of each bit having experienced a fault.

Linnea Grans-Samuelsson gave a tutorial on the difference between maximum probability decoding, where the decoder returns a maximally probable error compatible with a syndrome, and a maximum likelihood (optimal) decoder, which computes the probability of each equivalence class of errors and returns a correction belonging to the most probable class.

I presented an overview of PyZX’s current capabilities: optimisation, visualisation, and circuit extraction. Then, I gave a demonstration of the graphical proof assistant ZXLive. This was followed by a discussion on desirable future software tools, with a particular emphasis on applications in quantum error correction.

We examined several directions for visualising basic quantum error correction and fault tolerance using the ZX calculus. These included analysing hook errors in the surface code, as well as understanding and unifying magic state distillation protocols.

Pauli errors that happen during the application of a logical non-Clifford gate can create random syndromes. This is a problem when simulating erroneous circuits and decoding them. We discussed how scalable ZX calculus can help in analyzing the effect of Pauli errors between logical gates in the third level of the Clifford hierarchy and stabilizer measurements. For diagonal gates, a normal form provides a compact representation, and we discussed possibilities for utilizing it in the context of simulating syndrome statistics and the propagation of Clifford errors through the circuit.

We completed the representation of the general tiger code X-part projector, which required introducing a multiplier analogue for the Fock basis and developing a scalable notation to package these elements in a compact form. However, the resulting constructions produced diagrams of considerable size and complexity. To mitigate this, we shifted attention to a simpler case – the cat code – and attempted to express its code states and codespace projectors directly as CV ZX-diagrams. Despite these efforts, we were ultimately unable to obtain a satisfactory diagrammatic formulation.