Fault-tolerance by construction

Aleks Kissinger + Oxford CS Quantum Group

Oxford QEC Workshop 2026

ZX-calculus

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


Optimisation	Simulation & Verification	Error Correction

ZX diagrams

Using 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 {-}...{-}\|$

ZX diagrams

...we can build many gates:
$CNOT =$ $CZ =$ $H =$ $:=$

$R_Z[\alpha] =$ $R_X[\alpha] =$
...and measurements:
$\Pi_{Z...Z}^{(k)} =$ $\Pi_{X...X}^{(k)} =$

...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"

Quantum error correction

...is done by encoding some space of logical qubits
into a bigger space of physical qubits:

$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

Example: GHZ code

$\leadsto$

Example: GHZ code

This is a stabiliser measurement. In the absence of errors, it doesn't do anything!

Example: GHZ code

...but some errors will flip the measurement outcome,
giving an error syndrome.

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

ZX can give us an answer:

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

What we need is a notion of equivalence that captures the behaviour of circuits (or ZX-diagrams) in the presence of errors, fault-equivalence:

$D \ \hat{=}\ E$

This is a finer-grained notion of equivalence than the usual one:

$D\ \hat{=}\ E \implies D = E$

$D = E \ \ \not\!\!\!\implies D\ \hat{=}\ E$

Fault-equivalence

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

$C \ \hat{=}\ D$

if for any undetectable fault $F$ of weight $w$ on $C$, there exists an undetectable fault $F'$ of weight $\leq w$ on $D$ such that $C[F] = D[F']$
(and vice-versa).

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!