Fault-tolerance by construction

Aleks Kissinger

Fault-tolerant Quantum Technologies, Benasque 2026

Joint work with: Benjamin Rodatz, Boldiszár Poór, Linnea Grans-Samuelsson, Andrey Khesin, Sarah Meng Li, John van de Wetering, Richie Yeung, Max Schweikart, Max Rüsch

ZX-calculus

ZX := a handy tool for working with quantum
computations using graph rewriting

Optimisation	Simulation & Verification	Error Correction

Optimising circuits the old-fashioned way

A better idea: decompose a circuit into a ZX diagram

ZX diagrams

• Gates are represented using more basic building blocks, called spiders:

  	$:=$	$\ \ |0...0\rangle\langle 0...0| + e^{i \alpha} |1...1\rangle\langle 1...1|$
  	$:=$	$\ \ |{+}...{+}\rangle\langle {+}...{+}| + e^{i \alpha} |{-}...{-}\rangle\langle {-}...{-}|$

• E.g.

  $\textit{CNOT} :=$     $\sqrt{X} :=$     $Z_\alpha :=$

• Wire order doesn't matter $\Rightarrow$ treat ZX-diagrams as undirected graphs

...then use the ZX calculus

A complete set of equations for qubit QC

Clifford ZX calculus

A complete set of equations for qubit Clifford QC

efficient synthesis, equality checking, classical simulation, ...

$\approx$ "graphical stabiliser theory"

PyZX

• Open source Python library for circuit optimisation, experimentation, and education using ZX-calculus

QuiZX

• Large scale circuit optimisation and classical simulation library for ZX-calculus

ZXLive

• GUI tool based on PyZX

Paritea

Quantum error correction

• $E$ (or just $\textrm{Im}(E)$) defines a quantum error correcting code
• Fault-tolerant quantum computing (FTQC) requires methods for:
  • encoding/decoding logical states and measurements
  • measuring physical qubits to detect/correct errors
  • doing fault-tolerant computations on encoded qubits
  
  

QEC in ZX 101...

Quantum Gates

$CNOT =$     $CZ =$     $H =$ $:=$

$R_Z[\alpha] =$     $R_X[\alpha] =$

Quantum Measurements

$|k\rangle\langle k| \propto$  

...collapse the quantum state to a fixed one,
depending on the outcome $k \in \{0,1\}$:

Multi-qubit measurements

$k = 0$     $\Rightarrow$     $+1$ eigenspace of $Z \otimes \ldots \otimes Z$
$k = 1$     $\Rightarrow$     $-1$ eigenspace of $Z \otimes \ldots \otimes Z$

Multi-qubit measurements

Any other multi-qubit measurement can be obtained by conjugating with local Cliffords, e.g.

$X \otimes \ldots \otimes X$       $\leadsto$         $=$  

Modelling errors

Pauli errors are modelled by introducing X, Y, or Z
flips on edges in a ZX-diagram:

Modelling errors

Anti-commuting errors flip measurement outcomes:

Example: GHZ code

Example: GHZ code

Example: GHZ code

Graphical encoders

...give us a simple dictionary between QEC codes and ZX-diagrams, e.g. the GHZ code can be fully represented as:

Example: Steane code

Example: Surface code

Example: [[8, 3, 2]] Colour code

Fault-tolerant computation

But codes are only half the story in FTQC. We also need to know how to implement operations fault-tolerantly.

Consider a 4-qubit $Z \otimes Z \otimes Z \otimes Z$ measurement:

This isn't a basic operation (for most quantum computers).
How can we implement this?

Example: measurement circuits

Q: Is the LHS really equivalent to the RHS?

A: It depends on what "equivalent" means.

Example: measurement circuits

They both give the same linear map, i.e. the behave the same in the absence of errors.

But they behave differently in the presence of errors, e.g.

Solution: Fault equivalence

$D \ \hat{=}\ E$

Error locations

Similar to space-time codes, we can model faults by tracking their locations in a circuit or ZX-diagram.

Applying a Pauli to a Circuit/Diagram

• For a circuit/diagram with a set $\mathcal L$ of fault locations, a fault is a Pauli

  $F \in \mathcal P^{|\mathcal L|}$

• We can apply any Pauli $F \in \mathcal P^{|\mathcal L|}$ to a diagram $D$ by plugging it in, to make a linear map $D[F]$
  • convention: interpret measurements as projection onto $+1$, and assume $D[I] \neq 0$
  
  
• There are 3 possibilities...

$F$ does nothing

$D[F] = D[I]$

i.e. it is a gauge of the diagram

$F$ is detectable

$D[F] = 0$

$F$ is undetectable

$D[F] \neq 0$ and $D[F] \neq D[I]$

Pauli error models

• A Pauli error model is a choice of basic faults $F_1, \ldots, F_b$. The weight of a fault is the number of basic faults in its product.
  
  
  
• Ex: Phenominological/naive model:

  basic faults $:=$ all single-qubit Paulis

• Ex: Circuit-level noise model:

  basic faults $:=$ all single-qubit Paulis (memory errors) +
  some multi-qubit Paulis (correlated gate/measurement errors)

Pauli error models

Ex: sub-models, where we remove some basic faults to represent components we assume are noise-free:

Fault-equivalence

Definition: Two circuits (or ZX-diagrams) $C, D$ are called fault-equivalent:

$C \ \hat{=}\ D$

Fault-equivalence

• While all the ZX rules preserve map-equivalence, only some rules preserve fault-equivalence.
• It turns out the ones that do, e.g.

               

  ...are very useful for compiling fault-tolerant circuits!

Paradigm: Fault-tolerance by construction

arXiv:2506.17181

Idea: start with an idealised computation (i.e. specification) and refine it with fault-equivalent rewrites until it is implementable on hardware.

Specification/refinement has been used in formal methods for classical software dev since the 1970s. Why not for FTQC?

Example: Cat state preparation

Example: Cat state preparation

Example: Shor-style syndrome extraction

Example: A new variation on Shor

Example: Steane-style syndrome extraction

Example: A new variation on Steane (the same trick)

FTbC Survey

Floquetification

B Rodatz, B Poór, AK. arXiv:2410.17240

See also: A. Townsend-Teague, J. Magdalena de la Fuente, M. Kesselring. arXiv:2307.11136

Completeness for Fault-equivalent Rewriting

M Rüsch, AK, B Rodatz. arXiv:2510.08477

Ultra-low overhead syndrome extraction for the Steane Code

B Poór, B Rodatz, AK. arXiv:2511.13700

an 11-CNOT (optimal*) syndrome extraction circuit for the Steane code

Ultra-low overhead syndrome extraction for the Steane Code

SpiderCat: Optimal FT Cat State Preparation

A Khesin, S Li, B Poór, B Rodatz, J van de Wetering, R Yeung. arXiv:2603.05391

gives CNOT lower bounds for all sizes $n$ and max FT error weight $t$

+ optimal explicit constructions for most pairs
$(n \leq 100, t \leq 5)$ and $(n \leq 50, t \leq 7)$

MWPM-Decodability Preserving Rewriting

M Schweikart, L Grans-Samuelsson, AK, B Rodatz. arXiv:2603.19522

matchable QEC codes ⇒ FT syndrome extraction circuits with matchable DEMs

Lots to do!

• Automatically building/optimising FT circuits
  (e.g. via heuristic search or AI)
  
• Logical computation and measurement
  (esp. in non-traditional QEC paradigms, like dynamical codes)
  

Lots to do!

• Scalability, compositionality, and FT architectures
  
• Tooling, automation, and integration
  (PyZX/QuiZX/ZXLive/Paritea/Stim)
  

Lots to do!

• Decoding errors and preserving efficient decodability
  (beyond matchable codes/circuits)
  
• Reasoning about stochastic noise
  (fault-equiv. = adversarial/worst-case noise behaviour)
  

Image credit: Riverlane and Google Quantum AI

Thanks!

Fault Tolerance by Construction » arXiv:2506.17181

Collabs: Benjamin Rodatz, Boldiszár Poór, Linnea Grans-Samuelsson, Andrey Khesin, Sarah Meng Li, John van de Wetering, Richie Yeung, Max Schweikart, Max Rüsch

https://zxcalc.github.io/book
(free book! Ch 12 = ZX + QEC)

https://zxcalculus.com
(350+ ZX papers, ~10% tagged QEC, online seminars, Discord)