Verifying Fault-Tolerance of Quantum Error

Correction Codes

Kean Chen1 , Yuhao Liu1 , Wang Fang2 , Jennifer Paykin3 , Xinchuan Ryan Wu3 ,
Albert Schmitz3 , Steve Zdancewic1 , and Gushu Li1
1
University of Pennsylvania
arXiv:2501.14380v1 [quant-ph] 24 Jan 2025

2
University of Edinburgh
3
Intel

Abstract. Quantum computers have advanced rapidly in qubit number

and gate fidelity. However, they would still lack practicalness without
utilizing fault-tolerant quantum error correction code (QECC) imple-
mentations to suppress noise. Manually or experimentally verifying the
fault-tolerance of complex QECCs is impractical due to the vast error
combinations. This paper formalizes fault-tolerance within the language
of quantum programs. By incorporating the techniques of quantum sym-
bolic execution, we provide an automatic verification tool for quantum
fault-tolerance. We evaluate and demonstrate the effectiveness of our tool
on a universal set of logical operations across different QECCs.

1 Introduction

Quantum computers, believed to have the potential to address many challeng-

ing classical problems [38,42], have recently advanced rapidly in hardware, with
multiple devices demonstrating over 102 ∼ 103 physical qubits [6,35,13,17]. How-
ever, real-world quantum computers suffer from noise, and practical quantum
computation will be unrealistic without using quantum error correction codes
(QECCs) [20,22]. State-of-the-art small-scale experiments on QECCs [6,2,3,43]
have been shown to successfully reduce the logical error rate of certain opera-
tions, marking the achievement of preliminary fault-tolerant quantum computing.
The fault-tolerance of a quantum operation, i.e., its ability to succeed despite
suffering from faults, guarantees its fundamental practicality. Human proofs and
experiments can be applied to low-distance and few-qubit codes by enumerat-
ing the basis of the code space under different error combinations and check-
ing the equivalence. However, as more advanced and extensive QECCs [32,10]
are proposed for better code performance, manual testing of fault-tolerance be-
comes impossible due to numerous error combinations and extensive code space,
prompting the emergence of computer-aided techniques.
Although simulating universal quantum circuits is computationally hard,
most QECCs are implemented only with stabilizer circuits and can be efficiently
simulated [20,21,19,48]. Moreover, quantum errors can be discretized, making it
possible to test the fault-tolerance of QECCs mechanically.
2 Chen et al.

Symbolic execution [29] is a well-established technique in classical computing

for program analysis and verification.Existing works [4,15,36] have extended this
method to prove the semantic correctness of ideal (fault-free) quantum programs.
However, the correctness in ideal case does not guarantee fault-tolerance on
actual devices since errors can propagate within physical operations and cause
unexpected malfunctioning.
In this paper, we propose a verification tool for quantum fault-tolerance.
We extend the semantics of classical-quantum programs [55,54] with presence
of faults and present an automatic strategy for error analysis with symbolic
execution [15,4]. We divide a QECC-encoded quantum circuit into four essen-
tial fragments—preparation, gate, measurement, error correction—and verify the
conditions that must hold for them to be fault-tolerant. A symbolic expression
for fault-tolerance is automatically generated and fed into an SMT solver to
check the fault-tolerance.
The major contributions of this paper are as follows:
1. We define the semantics of quantum programs with faulty executions to
reason about the influence of faults. Then, we formally characterize the fault-
tolerance properties of quantum programs, adapting definitions from [22,23].
2. We prove a series of discretization lemmas for quantum fault tolerance and
introduce a symbolic execution framework for verifying quantum fault tol-
erance based on the stabilizer formalism.
3. Our symbolic execution framework covers a set of operations for universal
fault-tolerant quantum computing, including the magic state preparation.
4. We demonstrate the effectiveness of our verification tool on different QECCs.

2 Background
This section introduces essential background concepts of quantum computing
and quantum error correction. More details can be found in [38,20,22].

2.1 Quantum Computing Basics

We assume the reader is familiar with finite-dimension complex linear algebra.
The state space of a quantum system is described by a d-dimensional complex
Hilbert space Hd . A pure state is a unit vector |ψ⟩ ∈ Hd . A mixed state is
P {|ψi ⟩} with probability
a statistical ensemble of pure states P pi , described by the
partial density operator ρ = i pi |ψi ⟩⟨ψ|i . If i pi = 1, then ρ is also called
a density operator. A pure state |ψ⟩ can also be regarded as the the density
operator ρ = |ψ⟩⟨ψ|.
We use quantum channel to describe a general quantum evolution, which
is mathematically a completely positive trace-preserving map E on the space of
density operators. Specifically, E has the following non-unique form:

Ei ρEi† , s.t.
X X †
E(ρ) = Ei Ei = I,
i i
 Verifying Fault-Tolerance of Quantum Error Correction Codes 3

where the operators {Ei } are called Kraus operators. In particular, a quantum
gate corresponds to a unitary quantum evolution can be described by a unitary
channel: E(ρ) = U ρU † , where U is a unitary matrix.
A quantum measurement is described by a set of linear operators {Mi }
such that i Mi† Mi = I. When measuring a state ρ, the probability of outcome
P

i is pi = tr(Mi ρMi† ), after which the state collapses to ρ′ = Mi ρMi† /pi .

2.2 Stabilizer Formalism

The following unitaries are called the Pauli matrices:

       
10 01 0 −i 1 0
I= , X= Y = Z=
01 10 i 0 0 −1

An n-qubit Pauli operator P is a tensor product of n Pauli matrices σi ∈

{I, X, Y, Z} with a global phase c ∈ {1, −1, i, −i}:

P = c · σ1 ⊗ · · · ⊗ σn .

The weight of the Pauli operator P is the number of indices i such that
σi ̸= I. Note that the set of all n-qubit Pauli operators forms a group Pn under
matrix multiplication.
A state |ψ⟩ is stabilized by a unitary U if U |ψ⟩ = |ψ⟩ and U is called the
stabilizer of |ψ⟩. Suppose {P1 , . . . , Pm } is a set of m commuting and indepen-
dent 4 n-qubit Pauli operators such that Pi ̸= ±I and Pi2 ̸= −I. These Pauli
operators generate a group G = ⟨P1 , . . . , Pm ⟩ by matrix multiplication. Sup-
pose V is the subspace containing the states stabilized by elements in G, i.e.,
V := {|ψ⟩ | ∀P ∈ G, P |ψ⟩ = |ψ⟩}, then G is called the stabilizer group of
V , and the group elements P ∈ G are called the stabilizers of V . Particu-
larly, P1 , . . . , Pm are called the generators. Note that V is a 2n−m -dimensional
subspace. In particular, if m = n, then V is a one-dimensional subspace.
An n-qubit unitary U is called an Clifford unitary if it maps Pauli operators
to Pauli operators under conjugation, i.e., ∀P ∈ Pn , U P U † ∈ Pn . All n-qubit
Clifford unitaries can be generated by the H, S, and CNOT gates [1,38]. There
is a special type of quantum circuit called the stabilizer circuits, which con-
tains only the following elements: 1) preparing qubits into the computational
basis; 2) applying Clifford gates; 3) measuring qubits in the computational ba-
sis. Stabilizer circuits are vastly utilized in quantum error correction and can be
simulated efficiently by classical computers [21].

2.3 Quantum Error Correction

Quantum computers in the real world suffer errors that will significantly impact
the outcome. A quantum error can be described by a quantum channel, referred
4
Each Pj cannot be written as a product of others.
4 Chen et al.

to asPquantum error channel. The weight of a quantum error channel E :

ρ 7→ i Ei ρEi† is the smallest integer r such that each Ei is a linear combination
of Pauli operators with weight ≤ r (note that the Pauli operators form a linear
basis of the matrix space).
Due to the no-cloning theorem [38], it is impossible to duplicate quantum
states to resist errors. Instead, we employ quantum error correction codes to
encode quantum information, which can detect and correct errors. A quantum
n
error correction code (QECC) C uses n physical qubits (H2 ) to encode k
k n
logical qubits (H2 ). Specifically, it assigns a 2k -dimensional subspace H′ ⊆ H2 ,
k
called the code space, and an isomorphism between H′ and H2 . If it is clear
from the context, we will use C to refer to both the QECC and its code space.
The error correction process of a QECC consists of the following steps:
– Syndrome measurement: applying a list of measurements on physical
qubits to detect potential errors.
– Recovery: performing recovery operations based on the outcome of the
syndrome measurement.
The vast majority of QECC are stabilizer codes. For a stabilizer code C,
its code space is the subspace stabilized by a stabilizer group G = ⟨P1 , . . . , Pm ⟩,
where P1 , . . . , Pm are Pauli operators. Note that the code space is of dimension
2n−m . Therefore, it encodes k = n − m logical qubits. The error syndromes
can be obtained by performing Pauli measurement of the generators P1 , . . . , Pm .
A Pauli error E that anticommutes with a generator can be detected by the
measurement of this generator. The code distance d is defined as the smallest
integer t such that there exists a Pauli operator of weight t acting as a non-trivial
logical operation on the code space C.
Throughout this paper, we will consider stabilizer codes with code parame-
ters [[n, k, d]], where n, k and d stand for the number of physical qubits, number
of encoded logical qubits and code distance, respectively.

2.4 Error Propagation and Fault Tolerance

Given a QECC C and a state in the code space |ψ⟩ ∈ C. A quantum state ρ is
said to have an r-qubit error w.r.t. |ψ⟩ if there exists an error channel E with
weight r such that ρ = E(|ψ⟩⟨ψ|). In particular, if the error is a Pauli error (i.e.,
ρ = P |ψ⟩⟨ψ|P ), then we simply say ρ has r errors.
While QECCs effectively detect existing errors on quantum states, the er-
ror correction process and logical operations can introduce new errors during
executions. Even worse, errors may propagate among the qubits. For example,
Figure 1a shows an error propagation in an implementation of a multi-qubit
Pauli measurement (which corresponds to a logical Pauli measurement). In con-
trast, Figure 1b shows an “transversal” implementation, where
√ the ancilla qubits
are initialized to the cat state |cat⟩ = (|0000⟩ + |1111⟩)/ 2. Here, a single er-
ror will not propagate to two or more errors, which, roughly speaking, is called
fault-tolerance 5 . However, being entangled, the cat state itself cannot be pre-
5
The formal definition of fault-tolerance is given in Section 4
 Verifying Fault-Tolerance of Quantum Error Correction Codes 5
H
X
H

⇝
| 0⟩ H H |cat⟩ ⊕
H
H
P1
P2 P3 P1

⇝⇝
P3 P4 P2
P4
P3

(a) Multi-qubit Pauli measurement using P4

a single ancilla, in which a Pauli-X error
on the ancilla qubit will propagate to two (b) Multi-qubit Pauli measurement us-
Pauli errors P3 , P4 on the data qubits. ing the cat state.

Fig. 1: Two implementations of multi-qubit Pauli measurement P1 ⊗P2 ⊗P3 ⊗P4 .

pared transversally, requiring a more elaborate design (see Section 8.1) for fault-
tolerance. This leads to a fundamental question:
Given a QECC and an implementation of a logical operation on it, how can we
tell if it is fault-tolerant?

To answer this, we propose our verification tool, which can identify both
fault-tolerant and non-fault-tolerant designs.

3 Related Work

Formal logic for quantum computing. There are extensive works on building
formal logic to reason quantum programs, including quantum assertions [33],
quantum Hoare logic [53,34,18,57], logic for erroneous quantum programs [50,27],
ZX-calculus [40,41], etc. However, most of these works require human interaction,
and none focus on fault-tolerance. In contrast, our work formally characterizes
the quantum fault-tolerance and provides an automated verification tool.
Automatic testing and verification of quantum programs. Other works
focus on proving properties of quantum programs based on certain automatic
techniques, including quantum symbolic execution [36,15,4,16], equivalence check-
ing of quantum programs [11,12,52,25], program invariance generation [56,28],
automatic testing and verification [14,51,46,24], etc. However, these tools are not
designed for targeting the fault-tolerance of QECCs.
Experiments of Fault-Tolerance. Recently, experiments have demonstrated
preliminary fault-tolerance with small-scale QECCs, including surface codes on
superconducting qubits [2,3], and color codes on neutral atom devices [6,43].
However, these works are mostly early-stage demonstrations on hardware. They
provide realistic numerical results but do not offer solid evidence for general
fault-tolerance. Our work can formally verify general fault-tolerance on various
logical operations and QECCs without limitations imposed by real devices.
6 Chen et al.

4 Quantum Fault Tolerance

In this section, we introduce a formalization of quantum fault-tolerance using
the language of classical-quantum programs [55,54] with faulty transitions.
First, we introduce the notion of quantum gadget [22], Given a QECC C,
a quantum gadget is an implementation of a logical operation on C by a set of
physical operations and is in one the following types:
– Preparation: prepare a logical state, e.g., the logical state |0⟩.
– Measurement: measure on a logical basis, e.g., the logical Z-basis mea-
surement {|0⟩⟨0|, |1⟩⟨1|}.
– Gate: perform a logical quantum gate, e.g., the logical CNOT gate.
– Error correction: detect and correct physical errors in the logical state,
e.g., Shor’s error correction process.
A quantum gadget must consistently perform the same on the logical state in
the ideal (fault-free) scenario for a specific type of operation. In the real world,
however, physical operations within a quantum gadget are faulty, potentially
causing more errors and even destroying the logical state. Therefore, a good
quantum gadget should also be able to tolerate faults, i.e., fault-tolerant.

4.1 Classical-Quantum Program (cq-prog )

Our goal is to verify a quantum gadget’s fault tolerance by investigating how
internal faults affect it. We note that general quantum gadgets are not lim-
ited to unitary circuits but also include mid-circuit measurements with sophis-
ticated classical control flows (e.g., classical oracles, branches, and repeating
a specific sub-procedure until some condition is satisfied). Therefore, we for-
malize the quantum gadget using the language of the classical-quantum pro-
gram [53,15,54,55].

Definition 1 (Syntax of Classical-Quantum Programs (cq-prog )).

A classical-quantum program (cq-prog) on qubits q1 , . . . , qn with classical vari-
ables and repeat-until-success structure is defined by the following syntax:

S ::= S1 ; S2 (sequence) | qi := |0⟩ (initialization)

| U (q) (unitary) | x := measure qi (measurement)
| x := e (assign) | if e then S1 else S2 (conditionals)
| y := f (x) (classical oracle) | repeat S until e (repeat-until)

The notations used in Definition 1 are explained as follows: qi is a qubit, x

and y are classical variable, e is a classical expression, f is a classical oracle,
q = qi , . . . , qj is an arbitrary set of qubits; U (q) performs a unitary gate U on
a set of qubits q; x := measure qi performs a computational-basis measurement
{|0⟩⟨0|, |1⟩⟨1|} on the qubit qi and stores the result (0 or 1) in the classical variable
x; repeat S until e performs the quantum program S until the expression e is
evaluated as true.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 7

Then, the execution of a classical-quantum program can be described in terms

of transition between the classical-quantum configurations.
Definition 2 (Classical-Quantum Configuration). A classical-quantum
configuration is a triple ⟨S, σ, ρ⟩, where S is a cq-prog, σ : x 7→ v is a map
from classical variables to classical values, and ρ is a partial density operator
describing the (sub-normalized) quantum state of the qubits.
We can now define the operation semantic of a cq-prog by specifying the
transition relationship between the classical-quantum configurations.

Definition 3 (Ideal Transition). The following rules define the ideal transi-
tion relation “→” between classical-quantum configurations:

(IN) ⟨qi := |0⟩, σ, ρ⟩ → ⟨↓, σ, ρqi :=|0⟩ ⟩ (UT) ⟨U (q), σ, ρ⟩ → ⟨↓, σ, Uq ρUq† ⟩
(M0) ⟨x := measure qi , σ, ρ⟩ → ⟨↓, σ[0/x], |0⟩qi ⟨0|ρ|0⟩qi ⟨0|⟩
(M1) ⟨x := measure qi , σ, ρ⟩ → ⟨↓, σ[1/x], |1⟩qi ⟨1|ρ|1⟩qi ⟨1|⟩
(AS) ⟨x := e, σ, ρ⟩ → ⟨↓, σ[σ(e)/x], ρ⟩ (CO) ⟨y := f (x), σ, ρ⟩ → ⟨↓, σ[f (x)/y], ρ⟩
⟨S1 , σ, ρ⟩ → ⟨S1′ , σ ′ , ρ′ ⟩
(SC)
⟨S1 ; S2 , σ, ρ⟩ → ⟨S1′ ; S2 , σ ′ , ρ′ ⟩
σ |= e
(CT)
⟨if e then S1 else S2 , σ, ρ⟩ → ⟨S1 , σ, ρ⟩
σ |= ¬e
(CF)
⟨if e then S1 else S2 , σ, ρ⟩ → ⟨S2 , σ, ρ⟩
(RU) ⟨repeat S until e, σ, ρ⟩ → ⟨S; if ¬e then S ′ else ↓, σ, ρ⟩
where S ′ = repeat S until e

where in rule (IN), ρq:=|0⟩ = |0⟩q ⟨0|ρ|0⟩q ⟨0| + |0⟩1 ⟨1|ρ|1⟩q ⟨0|; in rule (UT), Uq
means a unitary that acts as U on q = qi . . . qj , and acts trivially on other qubits.

Now we can see that the behavior of a quantum gadget in the ideal (fault-free)
case can be completely described by the semantics of a cq-prog .

4.2 Execution with Faults

Real-world quantum gadgets suffer from faults. In this subsection, we formalize

the behavior of a quantum gadget (execution of a cq-prog) with presence of
faults. We assume that all the classical operations (i.e., (AS), (CO), (CT), (CF),
and (RU)) are flawless, and only quantum operations (i.e., (IN), (UT), (M0),
and (M1)) can be faulty. When a fault happens, the original quantum operation
is replaced by an arbitrary quantum operation acting on the same qubits. The
corresponding transition is called faulty transition.

Definition 4 (Faulty Transition). The following rules define the faulty tran-
sition “⇝” between classical-quantum configurations when faults occur during the
8 Chen et al.

execution of a quantum program:

(F-IN) ⟨q := |0⟩, σ, ρ⟩ ⇝ ⟨↓, σ, Eq (ρ)⟩ (F-UT) ⟨U (q), σ, ρ⟩ ⇝ ⟨↓, σ, Eq (ρ)⟩

(F-M0) ⟨x := measure q, σ, ρ⟩ ⇝ ⟨↓, σ[0/x], E0,q (ρ)⟩
(F-M1) ⟨x := measure q, σ, ρ⟩ ⇝ ⟨↓, σ[1/x], E1,q (ρ)⟩

where in rules (F-IN) and (F-UT), Eq and Eq can be arbitrary trace-preserving

quantum operations that act non-trivially only on q and q, respectively; in rules
(F-M0) and (F-M1), E0,q and E1,q can be arbitrary (non-trace-preserving) quan-
tum operations acting non-trivially only on q. We omit the rule (F-SC) here as
it is simply analogous to the rule (SC) in Definition 3.

Now, we can describe the execution of a cq-prog with faults using the following
faulty transition tree.
Definition 5 (Transition Tree with Faults). Let S0 be a cq-prog, σ0 be
a classical state and r ≥ 0 be an integer. An r-fault transition tree T starting
with (S0 , σ0 ) is a (possibly infinite) tree with classical-quantum configurations as
nodes and satisfies the following conditions:
1. The root is ⟨S0 , σ0 , ρe⟩, where ρe is an indeterminate quantum state.
2. A node is of the form ⟨↓, σ, ρ⟩ iff. it is a leaf node.
3. A node is of the form ⟨x := measure q; S, σ, ρ⟩ iff. it has two children, either
generated by (M0) and (M1), or generated by (F-M0) and (F-M1). Fur-
thermore, for the latter case, the quantum operations E0,q and E1,q in the
transition rules satisfy that E0,q + E1,q is trace-preserving.
4. If a node v is not of the form ⟨↓, σ, ρ⟩ or ⟨x := measure q; S, σ, ρ⟩, then it
has only one child v ′ such that v → v ′ or v ⇝ v ′ (cf. Definition 3 and 4).
5. Each path contains at most r faulty transitions “⇝”.
Let ρ0 be a concrete quantum state. We use T (ρ0 ) denotes the tree obtained by
replacing the indeterminate quantum state ρe with ρ0 in root node.
If we fix a cq-prog S and a classical state σ0 , then any r-fault transition tree
T starting with (S0 , σ0 ) corresponds to a well-defined quantum channel.
Proposition 1. Let S0 be a quantum program, σ0 be a classical state and r ≥ 0.
If T is an r-fault transition tree starting with (S0 , σ0 ), then the map ET :
X
ET : ρ 7→ ρ′
⟨↓,σ,ρ′ ⟩∈T (ρ)

is a quantum channel (not necessarily trace-preserving).

Note that the semantics of a cq-prog in presence of faults is nondeterministic.
This is because there can be infinite many r-fault transition trees starting with
(S0 , σ0 ), where each transition tree corresponds to a valid semantics with r faults.
In this context, each tree T is also referred to as an r-fault instantiation of
(S0 , σ0 ), or simply an instantiation of S0 with r faults, if σ0 = ∅.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 9

4.3 Formalization of Quantum Fault Tolerance

Given the definition of quantum gadgets and cq-prog, we can formally define
quantum fault-tolerance based on the seminal works [22,23]. Different from their
definitions, we separate the fault-tolerance property of a quantum gadget from
its semantical correctness in the fault-free case, and we further assume that a
quantum gadget always produces the correct semantics in the fault-free case.
In this section, we fix a QECC C with distance d and set t := ⌊ d−1
2 ⌋ for the
number of correctable errors. The following symbols will be used:

– “ ” stands for a logical block of C formed by physical qubits.

– r stands for an arbitrary weight-r error channel.

– , , and EC stand for the preparation, measurement, (two-

qubit) gate and error correction gadgets, respectively.
– “s” near a gadget indicates s faults appear in the execution of the gadget.

First, we introduce the definition of FT preparation gadget.

Definition 6 (Fault Tolerant Preparation). A preparation gadget is fault-

tolerant if the following holds:
s
= s , when s ≤ t. (1)

That is, a cq-prog S implements the FT preparation if for any s-fault instantia-
tion of S, s.t. s ≤ t, the prepared state has at most s errors.

Then, we introduce the FT gate gadget. For simplicity, we only present the
case for two-qubit gates, which can be easily extended to n-qubit gates.

Definition 7 (Fault Tolerant Gate). A two-qubit logical gate gadget is fault-

tolerant if the following holds:

s
r1 e
|ψ⟩ U = |ψ⟩ U , when r1 + r2 + s ≤ t, (2)
r2 e

where e = r1 + r2 + s. That is, a cq-prog S implements the FT-gate if for

any logical state |ψ⟩ with r1 and r2 errors on each logical block and any s-fault
instantiation of S, s.t. r1 + r2 + s ≤ t, the output state has at most e = r1 + r2 + s
errors on each block.

The fault tolerance of the measurement gadget dictates that the measurement
outcome should have the same distribution as in the ideal case.
10 Chen et al.

Definition 8 (Fault Tolerant Measurement). A measurement gadget is fault

tolerant if the following holds:
|ψ⟩ s = |ψ⟩
r , when r + s ≤ t. (3)
That is, a cq-prog S implements the FT-measurement if for any logical state |ψ⟩
with r errors and any s-fault instantiation of S, s.t. r + s ≤ t, the measurement
outcomes are the same (in distribution) as those in the fault-free case.
A fault-tolerant error correction gadget must not only prevent error propa-
gation but also eliminate errors in the input.
Definition 9 (Fault Tolerant Error Correction). An error correction gad-
get is fault tolerant if the following holds:
s
|ψ⟩ r EC = |ψ⟩ s , when r + s ≤ t. (4)
That is, a cq-prog S implements the fault tolerant error correction for any logical
state |ψ⟩ with r errors and any s-fault instantiation of S, s.t. r+s ≤ t, the output
state has at most s faults.

5 Discretization
The fault tolerance properties are defined over continuous error channels and
logical states, making it hard to reason. A common approach is breaking these
properties into discrete yet equivalent forms. However, the discretization theo-
rem for fault-tolerance [22,23] does not fit our cq-prog framework. Therefore, we
present our discretization theorems, allowing us to analyze and verify quantum
fault-tolerance on cq-prog in a systematic way.

5.1 Discretization of Faults

First, we show that faults can be discretized from arbitrary quantum channels
into Pauli channels, depending on the types of transitions.
Definition 10 (Transition Tree with Pauli Faults). Let S0 be a quantum
program, σ0 be a classical state and r ≥ 0 be an integer. An r-Pauli-fault
transition tree T starting with (S0 , σ0 ) is a transition tree (c.f. Definition 5),
such that all faulty transitions in it satisfy the following rules instead:
(PF-IN) ⟨q := |0⟩, σ, ρ⟩ ⇝ ⟨↓, σ, Pq ρq:=|0⟩ Pq ⟩
(PF-UT) ⟨U (q), σ, ρ⟩ ⇝ ⟨↓, σ, Pq Uq ρUq† Pq ⟩
(PF-M0) ⟨x := measure q, σ, ρ⟩ ⇝ ⟨↓, σ[0/x], P0,q |0⟩q ⟨0|Qq ρQq |0⟩q ⟨0|P0,q ⟩
(PF-M1) ⟨x := measure q, σ, ρ⟩ ⇝ ⟨↓, σ[1/x], P1,q |1⟩q ⟨1|Qq ρQq |1⟩q ⟨1|P1,q ⟩
where in rules (PF-IN) and (PF-UT), Pq and Pq are arbitrary Pauli operators
acting on q and q, respectively. In rules (PF-M0) and (PF-M1), P0,q , P1,q , Qq
are arbitrary Pauli operators acting on q. Furthermore, if a node is ⟨x :=
measureq; S, σ, ρ⟩ and its two children are generated by (PF-M0) and (PF-M1),
then both transitions share the same Pauli error Qq .
 Verifying Fault-Tolerance of Quantum Error Correction Codes 11

Such tree T is an r-Pauli-fault instantiation of (S0 , σ0 ). If σ0 = ∅, we call it

an r-Pauli-fault instantiation of S0 . Then, we have the following lemma.
Lemma 1. A gadget is fault tolerant if and only if it satisfies the corresponding
fault tolerance properties (c.f. Equations (1), (2), (3), (4)) with the Pauli fault
instantiation (see Definition 10).

5.2 Discretization of Inputs

Then, we show that the input can be discretized from arbitrary logical states
into logical computational bases with or without an additional logical state,
depending on the type of gadget.
Lemma 2. A gate or decoder gadget is fault tolerant if and only if it satisfies
the corresponding fault tolerance properties (c.f. Equations (2), (4)) on both the
k P2k −1 √
logical computational basis {|i⟩}2i=0−1 and the logical state |+⟩ := i=0 |i⟩/ 2k .
Lemma 3. A Z-basis measurement gadget is fault tolerant if and only if it satis-
fies the corresponding fault tolerance properties (c.f. Equation (3)) on the logical
k
computational basis {|i⟩}2i=0−1 .

6 Symbolic Execution for Fault-Tolerance Verification

We establish the framework of symbolic execution based on the quantum stabi-
lizer formalism, following the previous work [15] of quantum symbolic execution
for (non-FT) error correction programs. Specifically, we maintain a symbolic
configuration ⟨S, σ
e, ρe, P, φ, E⟩, where
– S is the quantum program to be executed,
– σ
e is a symbolic classical state,
– ρe is a symbolic quantum stabilizer state, parameterized by a set of symbols,
and is equipped with a set of stabilizer operations (see Section 6.1).
– P is the probability corresponding to the current execution path, which is
in fact a concrete number instead of a symbolic expression.
– φ is the path condition, expressing the assumptions introduced in an execu-
tion path of the cq-prog.
– E is a symbolic expression recording the number of Pauli errors injected
during the execution of faulty transitions.

6.1 Symbolic Stabilizer States and Operations

Definition 11 (Symbolic Stabilizer States). For any commuting and in-
dependent set {P1 , . . . , Pn |Pi ̸= ±I, Pi2 ̸= −I} of n-qubit Pauli operators and
Boolean functions g1 , . . . , gn over m Boolean variables, the symbolic stabilizer
state ρe(s1 , . . . , sm ) over symbols s1 , . . . , sm is a stabilizer state of
⟨(−1)g1 (s1 ,...,sm ) P1 , . . . , (−1)gn (s1 ,...,sm ) Pn ⟩,
where ⟨A1 , . . . , An ⟩ denotes the group generated by A1 , . . . , An .
12 Chen et al.

When it is clear from the context, we will omit the symbols s1 , . . . , sm using
ρe to denote ρe(s1 , . . . , sm ), and directly use ⟨A1 , . . . , An ⟩ to denote the stabilizer
state of the group generated by A1 , . . . , An .
There are four types of symbolic stabilizer operations:

1. A symbolic function IN(qi , ρe) for the initialization statement qi := |0⟩.

2. A symbolic function UT(U, q, ρe) for the unitary transform statement U (q).
3. A symbolic function M(qi , ρe) for the measurement statement x := measure qi .
4. A symbolic error injection function EI(q, ρe) for the faulty transitions.

The symbolic functions IN(qi , ρe), UT(U, q, ρe) and M(qi , ρe) are similar to those
described in [15].We will explain the symbolic error injection function EI(q, ρe)
here. Suppose ρe is a symbolic stabilizer state:

ρe = ⟨(−1)g1 (s1 ,...,sm ) P1 , . . . , (−1)gn (s1 ,...,sm ) Pn ⟩. (5)

The symbolic error injection function acts on ρe by injecting symbolic Pauli er-
rors. It returns a symbol recording the activation of those Pauli errors and the
symbolic state ρe after error injection. Specifically, it is defined as follows.

Definition 12 (Symbolic Error Injection). The symbolic Pauli error injec-

tion function EI(qi , ρe) is defined as

X
⊕eZ ·cZ X Z
EI(qi , ρe) = (eX ∨eZ , ⟨(−1)g1 (s1 ,...,sm )⊕eX ·c1 1 P1 , . . . , (−1)gn (s1 ,...,sm )⊕eX ·cn ⊕eZ ·cn Pn ⟩),

where eX and eZ are symbols recording the inserted Pauli-X and Pauli-Z errors,
cxi and cZi indicate whether Pi commutes with Xi and Zi , respectively.
If the symbolic Pauli error injection function is applied on a sequence of qubit
variables q = qj1 , . . . , qja , then EI(q, ρe) is defined as

EI(q, ρe) = (e1 ∨ · · · ∨ ea , ρe(a) ),

where (ei , ρe(i) ) = EI(qji , ρe(i−1) ) for i = 1, . . . , a and ρe(0) := ρe.

6.2 Symbolic Faulty Transitions

Now, we are able to define the symbolic faulty transitions, which are the key
components of the symbolic execution for fault-tolerance verification.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 13

Definition 13 (Symbolic Faulty Transitions). The following are the sym-

bolic faulty transition rules on the symbolic configurations:

(SF-IN) ⟨qi := |0⟩, σ e, ρe′ , P, φ, E + e⟩

e, ρe, P, φ, E⟩ ↠ ⟨↓, σ
where (e, ρe′ ) = EI(qi , IN(qi , ρe))
(SF-UT) ⟨U (q), σ e, ρe′ , P, φ, E + e⟩
e, ρe, P, φ, E⟩ ↠ ⟨↓, σ
where (e, ρe′ ) = EI(q, UT(U, q, ρ))
(SF-M) ⟨x := measure qi , σ e[s/x], ρe(3) , P P ′ , φ, E + e1 ∨ e2 ⟩
e, ρe, P, φ, E⟩ ↠ ⟨↓, σ
where (e2 , ρe(3) ) = EI(qi , ρe(2) ), (s, P ′ , ρe(2) ) = M(qi , ρe(1) ), (e1 , ρe(1) ) = EI(qi , ρe)
(SF-AS) ⟨x := e, σ
e, ρe, P, φ, E⟩ ↠ ⟨↓, σ
e[e
σ (e)/x], ρe, P, φ, E⟩
(SF-CO) ⟨y := f (x), σ
e, ρe, P, φ, E⟩ ↠ ⟨↓, σ
e[s/y], ρe, P, φ ∧ Cf (e
σ (x), s), E⟩
(SF-CT) ⟨if e then S1 else S2 , σ
e, ρe, P, φ, E⟩ ↠ ⟨S1 , σ
e, ρe, P, φ ∧ σ
e(e), E⟩
(SF-CF) ⟨if e then S1 else S2 , σ
e, ρe, P, φ, E⟩ ↠ ⟨S2 , σ
e, ρe, P, φ ∧ ¬e
σ (e), E⟩
e, ρe, P, φ, E⟩ ↠∗ ⟨↓, σ
⟨S, σ e′ , ρe′ , P ′ , φ′ , E ′ ⟩
(SF-RU)
⟨repeat S until e, σ e, ρe, P, φ, E⟩ ↠ ⟨↓, σ e′ , ρe′ , P ′ , φ′ ∧ σ
e′ (e), E ′ ⟩

where in rules (SF-IN), (SF-UT) and (SF-M), e, e1 and e2 are newly introduced
bit symbols recording the inserted faults, in rule (S-RU), ↠∗ stands for the tran-
sitive closure of ↠. We omit the rule (SF-SC) here as it is simply analogous to
the rule (SC) in Definition 3.

All these rules are straightforward and can be viewed as a symbolization of

the rules in Definition 10, except the rule (SF-RU) for the repeat-until-success
loop. Notably, it executes the loop body only once and then post-selects on suc-
cess (add success condition into the path condition). We will explain its condi-
tional validity in Section 6.3, and then conclude the soundness and completeness
of our verification tool in Section 6.5.

6.3 Repeat-Until-Success

Our cq-prog syntax includes a repeat-until-success statement, essentially a do-

while loop structure. However, analyzing general loops remains challenging in
both quantum and classical contexts. To circumvent this issue, we observe that
most quantum gadgets utilize the loop in a particular pattern, and the problem
become trackable if specific restrictions are imposed on the loop body.
For instance, in the fault-tolerant cat state preparation gadget, a repeat-
until-success structure is used to test the prepared state. Before each iteration,
all quantum and classical variables are reset before being used again. This pattern
is recognized as the memory-less repeat-until-success.

Definition 14 (Memory-Less Repeat-Until-Success). A repeat-until-success

loop “repeat S until e” is memory-less if all classical and quantum variables
used in the loop body S are reset before being used in each iteration.
14 Chen et al.

It suffices only to consider the last iteration of a memory-less repeat-until-

success structure. The intuition is straightforward: suppose t errors are injected
into the loop. Errors injected in iteration other than the last one have no effect
beyond that iteration. Therefore, the worst case is when all errors are injected
into the final iteration and if the fault tolerance property holds in the worst-case
scenario, it also holds in the general case.
The rule (S-RU) is also applicable in a more general case, where qubits can be
reused across iterations. For instance, in Shor’s error correction, syndrome mea-
surements are repeated until consecutive all-agree syndrome results of length
⌊ d−1
2 ⌋ + 1 are observed. Therefore, the quantum qubits are not reset, mean-
ing errors in one iteration can affect subsequent iterations. Nevertheless, upon
closer examination, we observe that the syndrome measurement are implemented
“transversally” using cat states. Therefore, upon proper cat state preparation,
the errors will not propagate. As a result, any errors injected in an early iteration
can be commuted to the beginning of the last iteration without increasing the
total number of errors. Additionally, the syndrome measurements are projective,
which have idempotent semantics in the fault-free case. This means all the it-
erations other than the last one will not have effect and thus can be discarded.
We refer to this type of loop as a conservative repeat-until-success.
Definition 15 (Conservative Repeat-Until-Success). A repeat-until-success
loop “repeat S until e” is conservative if
– classical variables used in the loop body S are reset before used in each iter-
ation,
– the loop body S has idempotent semantics, i.e., ES ◦ ES = ES .
Consequently, if the loop is memory-less, the rule (S-RU) is valid. However
if the loop is not memory-less but still conservative, the validity of rule (S-RU)
requires an additional condition: errors must not propagate within the loop body
S. Fortunately, this can again be verified recursively on the loop body S using
our symbolic execution.

6.4 Verification of Fault Tolerance

Now, we are able to show how our symbolic execution works for verification of
the fault-tolerance properties (i.e. Equation 1, 2, 3 and 4). For simplicity, we
only demonstrate here the verification of a gate gadget for a logical gate U .
By Lemma 2, it suffices to check whether Equation (2) holds for the following
P2k −1 √
two cases: |ψ⟩ = |i⟩ for all i and |ψ⟩ = i=0 |i⟩/ 2k . Therefore, we construct
two symbolic stabilizer states respectively as:
ρeZ = ⟨P1 , . . . , Pn−k , (−1)s1 Z 1 , . . . , (−1)sk Z k ⟩,
(6)
ρeX = ⟨P1 , . . . , Pn−k , X 1 , . . . , X k ⟩,

where P1 , . . . , Pn−k are the Pauli stabilizers of the QECC C and Z i , X i are the
Pauli operators corresponding to the logical Zi and logical Xi in C, respectively.
We will only deal with the state ρeZ and the state ρeX can be handled analogously.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 15

Let ρe0 = ρeZ . We apply the Pauli error injection function EI on ρe0 recur-
sively for all physical qubits, i.e.,P (ei , ρei ) = EI(qi , ρei−1 ) for i = 1, . . . , n. Then
n
we define ρein := ρen and Ein := i=1 ei , which records the number of errors
injected in the symbolic state ρein . The initial symbolic configuration is set to
⟨S, ∅, ρein , 1, True, Ein ⟩, where S is the cq-prog implementing the gate gadget. By
applying our symbolic faulty transitions (see Definition 13) recursively on the
initial configuration, we obtain a set of output configurations cfgs = {cfgi }i ,
where the indices i refer to different execution paths and each cfgi is of the form
⟨↓, σ
e, ρe, P, φ, E⟩, in which P > 0 is a concrete positive number.
Then, the gadget is fault tolerant if and only if each symbolic configuration
in cfgs describes a set of noisy state that are not “too far” from the ideal output
state. Specifically, for each ⟨↓, σ e, ρe, P, φ, E⟩ ∈ cfgs, let {s1 , . . . , sm } be the set of
symbols involved in this configuration (i.e., all the symbols occur in σ e, ρe, φ and
E). Then we need to check whether the following holds

∀s1 , . . . , sm , φ → D(e
ρ, ρeideal ) ≤ E, (7)

where ρeideal is the symbolic state obtained by applying the (concrete) ideal uni-
tary transform U on ρe0 , and D(e ρ, ρeideal ) represents the Pauli distance between
ρe and ρeideal , i.e., the minimal weight of a Pauli operator that can transform ρe
to ρeideal . Note that the computation of D(e ρ, ρeideal ) is not straightforward, but
can still be formulated in a first-order formula. Specifically, let P1 , . . . , Pn be the
unsigned stabilizers of ρe, which should also be the unsigned stabilizers of ρeideal
(otherwise we can direct conclude that the gadget is not fault tolerant). Suppose

ρe = ⟨(−1)g1 P1 , . . . , (−1)gn Pn ⟩, ρeideal = ⟨(−1)h1 P1 , . . . , (−1)hn Pn ⟩,

where gi and hi are functions taking symbols s1 , . . . , sm as inputs. Therefore,

ρ, ρeideal ) ≤ E can be expressed as
D(e

∃P, wt(P ) ≤ E ∧ hi ⊕ c(P, Pi ) = gi for i = 1, . . . , n, (8)

where P is a symbolic Pauli represented by a symbolic vector of length 2n, wt(P )

is the weight of P and c(P, Pi ) = 0 if P and Pi commutes and 1 otherwise.
Note that the existence quantifier is in fact applied on 2n variables. We can
further reduce it to n variables. To see this, note that the computation of c(P, Pi )
for i = 1, . . . , m involves multiplication (over GF(2)) of the matrix representing
the stabilizers with the vector representing P . Specifically, let M be the n × 2n
matrix, in which each row represents a stabilizer, and let v be the 2n-length
vector representing the symbolic Pauli P . Then, c(P, Pi ) = (M Λv)i , where Λ
is a 2n × 2n matrix with n × n identity matrices as its off-diagonal blocks. By
solving the linear system over GF(2), Equation (8) is equivalent to

∃w, wt(N w ⊕ p) ≤ E, (9)

where w is a n-length vector, N is a 2n × n matrix with columns spanning the

null space of M Λ, p is a particular solution of the linear equation M Λp = g ⊕ h,
16 Chen et al.

in which g and h are the n-length vectors with entries gi and hi , respectively.
As a result, we can reduce the number of quantified variables from 2n to n.
Interpreting D(e ρ, ρeideal ) ≤ E by Equation (9), we can use the SMT solver to
check the validity of Equation (7). The same method is also applied on ρeX (see
Equation (6)), and “fault-tolerant” is claimed if both checks on ρeZ and ρeX pass.

6.5 Soundness and Completeness

Here, we state our main theorem about the soundness and completeness of our
verification tool.
Definition 16 (Soundness and Completeness). Suppose alg is an algorithm
taking a cq-prog S as input. Then, for the task of verifying quantum fault toler-
ance, we define the soundness and completeness of alg as follows.
– Soundness: alg(S) returns “fault-tolerant” =⇒ S is fault-tolerant.
– Completeness: S is fault-tolerant =⇒ alg(S) returns “fault-tolerant”.
Theorem 1. Suppose S is a cq-prog implementing a quantum gadget with sta-
bilizer quantum operations.
– If the repeat-until-success statements in S is conservative, then our quantum
symbolic execution is sound.
– If the repeat-until-success statements in S is memory-less, then our quantum
symbolic execution is both sound and complete.
Moreover, when S is non-fault-tolerant, our quantum symbolic execution will
always return a fault instantiation (see Definition 5) that witnesses the fail of
fault-tolerance.

7 Verifying Magic State Distillation

It was shown that our quantum symbolic execution can verify the fault tolerance
of a Clifford quantum gadget. We still need one more non-Clifford quantum gad-
get towards universal quantum computing [37,45]. A practical way is using the
gate teleportation [38,23] with magic state distillation [31,9] to implement non-
Clifford gates. Since the teleportation circuit is already a stabilizer circuit, the
remaining problem is: how to verify fault tolerance of a magic state distillation
protocol.
Typically, a magic state distillation protocol employs a distillation code D.
It performs the error correction (or error detection) process of D on multiple
noisy magic states to yield a high-quality magic state encoded in D, followed
by the decoding. The code D must exhibit desirable properties for magic state
distillation, such as the transversality of the logical T -gate [49].
In the context of quantum fault tolerance, we instead use a concatenated code
with D as outer code and a QECC C (used for fault-tolerance) as inner code (i.e.,
each qubit of D is encoded in C). To better illustrate the idea of fault-tolerant
magic state distillation, we reformulate it in a two-party framework.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 17

– Bob works on physical qubits and produces logical qubits encoded in C

equipped with fault-tolerant stabilizer operations and non-fault-tolerant magic
state preparation.
– Alice works on the encoded qubits produced by Bob, and performs a magic
state distillation protocol using a distillation code D.

Specifically, Alice makes uses of the logical operations of C provided by Bob and
performs magic state distillation as follows:

1. Call the non-fault-tolerant magic state preparation to produce a set of noisy

magic states (encoded in C).
2. Call error correction process of C on each noisy magic state.
3. Prepare logical state |+⟩ encoded in D.
4. Implement logical-T gate of D by gate teleportation with noisy magic states.
5. Perform error correction of D.

All the steps except step 1 contain only stabilizer operations of C, which are (ver-
ified) fault-tolerant. Therefore, we only need to investigate how the errors from
the noisy magic states propagate through the distillation process. Intuitively,
step 2 ensures that the physical errors (in Bob’s view) are suppressed, and only
physical errors (in Alice’s view), which are logical errors in Bob’s view, can fur-
ther propagate. Fortunately, in Alice’s view, the gate teleportation is transversal,
so that the errors do not propagate between the qubits. Therefore, it suffices to
check whether Alice’s error correction (i.e., step 5) can correct the errors on the
magic state encoded in D.
Our quantum symbolic execution is not directly applicable for this case since
the magic state encoded in D is not a stabilizer state. Nevertheless, we can
circumvent it by making a generalization on the input. That is, we instead verify
a stronger statement: Alice’s error correction can correct errors on an arbitrary
state, not only on the magic state. Then, we can use a discretization lemma like
Lemma 2 to reduce it back to a verification task on stabilizer states. We remark
that Alice’s error correction itself is not required to be fault-tolerant, but only
need to be able to correct errors on the input, which we call semi-fault-tolerant.
Formally, we have the following theorem.

Theorem 2. Suppose a magic state preparation gadget is implemented with the

two-party distillation framework. Then this gadget is fault-tolerant if

– Bob’s stabilizer operations are fault-tolerant,

– Alice’s error correction process is semi-fault-tolerant.

The fault-tolerance of Bob’s stabilizer operations is verifiable by the quan-

tum symbolic execution introduced in Section 6). For the semi-fault-tolerance
of Alice’s error correction process, we can use the similar techniques but disable
the error injections in symbolic transitions. Consequently, our verification tool
is capable of verifying the magic state distillation, provided that the distillation
protocol fits within our two-party framework.
18 Chen et al.

8 Case Study

We implemented our verification tool for fault-tolerance based on the Julia [5]
package QuantumSE.jl [15]. Our experiments are carried out on a desktop with
AMD Ryzen 9 7950X and 64G of RAM, running Ubuntu 22.04.5 LTS. We use
Bitwuzla [39] 0.7.0 as our SMT solver.

8.1 Warm-up Example: Cat State Preparation

Cat state preparation is a crucial module in fault-tolerant (FT) quantum com-

puting, extensively used in various FT gadgets such as FT Pauli measurement
and Shor’s error correction [47]. A fault-tolerant 6 cat state preparation can be
implemented through the following pattern:

1. Prepare the cat state non-fault-tolerantly.

2. Perform check on the cat state.
3. If the check fails, discard the state and start over.

For the second stage, it suffices to perform parity check on pairs of qubits of the
cat state. However, we must carefully select which pairs of qubits to check.

Repeat: Repeat:

Prepare Check Prepare Check

| 0⟩ H | 0⟩ H
| 0⟩ | 0⟩
| 0⟩ | 0⟩
| 0⟩ | 0⟩

| 0⟩ m | 0⟩ m

Until m = 0 Until m = 0

(a) Non-FT cat state preparation. (b) FT cat state preparation.

Fig. 2: Comparison of 4-qubit cat state preparations with different checks. By

our verification tool, we found that the first is non-FT and the second is FT.

For example, using our verification tool, we found that the 4-qubit cat state
preparation with the check on the second and third qubits, as shown in Figure 2a,
turns out to be non-fault-tolerant. In contrast, our tool proves that when the
check is applied to the third and fourth qubits, as shown in Figure 2b, the cat
state preparation becomes fault-tolerant. Furthermore, by examining the fault
instance returned by the SMT solver, we found that the error pattern failing the
6
Although the cat state is not encoded in any QECC with positive code distance, we
can still define its fault-tolerance up to t faults as follows: for any s ≤ t, if s faults
occur during the cat state preparation, the output contain at most s errors.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 19

fault-tolerance of Figure 2a is a Pauli-X error injected at the control qubit just

before the third CNOT gate. This error propagates to two Pauli-X errors on the
first and fourth qubits, which can be detected by the parity check on the third
and fourth qubits, rather than the parity check on the second and third qubits.
The implementation of cat state
preparation also depends on the number
of faults it needs to tolerate. For example, Repeat:
consider the cat state preparation with
| 0⟩
checks on pairs of consecutive qubits, as Check1
| 0⟩
shown in Figure 3. At the first glance, the Check2
| 0⟩
checks cover and connect all the qubits of Check3
| 0⟩
the cat state and one may expect that any Prepare Check4
| 0⟩
Pauli-X error on the cat state will be de- Check5
| 0⟩
tected by the checks. However, using our Check6
| 0⟩
verification tool, we found that this im- Check7
| 0⟩
plementation is only fault-tolerant up to
2 faults, but fails to be fault-tolerant for Until ∀i, checki passes
3 faults. By further examining the fault
instance returned by the SMT solver, we Fig. 3: An implementation of 8-qubit
found that error pattern failing the fault- cat state preparation, which is, by
tolerance of Figure 3 includes: (1) a Pauli- our verification tool, proved to be
X error injected at the control qubit just FT up to 2 faults but disproved to
before the sixth CNOT gate in the prepa- be FT for 3 faults.
ration stage, further propagating to three
Pauli-X errors on the first, seventh and
eighth qubits; (2) a fail of the measurement in the first check, causing a false
negative check result; (3) a fail of a CNOT gate in the sixth check, causing a
false negative check result and an additional Pauli-X error on the sixth qubit.
Note that all the checks pass, since the first and sixth checks failed to detect
the errors. Consequently, these 3 faults ultimately cause 4 errors on the output
state, which violates the fault-tolerance condition.

8.2 Verification of Fault-Tolerance

We perform our verification tool on the fault-tolerant quantum gadgets over
various quantum error correction codes, such as color code [8,44], rotated surface
code [7,26], toric code [30]. The verification time is shown in Table 1. In our
evaluation, the preparation gadgets prepare the logical state |0⟩, (|00⟩ for toric
code), the measurement gadgets perform the logical-Z measurement (logical-Z1
for toric code) and the error correction gadgets are implemented using Shor’s
error correction process [47].
Moreover, we also perform our verification on the magic state distillation
protocol with quantum Reed-Muller code [49] as the distillation code. As shown
in Section 7, it suffices to verify semi-fault-tolerance of the error correction pro-
cess of the distillation code, provided the Clifford operations are already verified
fault-tolerant. The verification time is also showed in Table 1.
20 Chen et al.

QECC [[n, k, d]] Gadget Types Time (s)

Preparation 2.81
CNOT 1.36
[[7,1,3]]
Measurement 3.65
Error Correction 3.15
Color Code [8,44]
Preparation 13.91
CNOT 30.29
[[17,1,5]]
Measurement 27.92
Error Correction 20.98
Preparation 2.96
CNOT 1.27
[[9,1,3]]
Measurement 3.91
Error Correction 3.10
Rotated Surface Code [7,26]
Preparation 22.38
CNOT 181.72
[[25,1,5]]
Measurement 42.79
Error Correction 52.15
Preparation 4.42
CNOT 2.37
[[18,2,3]]
Measurement 5.53
Error Correction 4.51
Toric Code [30]
Preparation 818.34
CNOT 12168.51
[[50,2,5]]
Measurement 916.51
Error Correction 1918.95
Quantum Reed-Muller Code [49] [[15,1,3]] Error Correction 4.89

Table 1: Verification time for fault-tolerant gadgets over different QECCs. The
quantum Reed-Muller code is used as distillation code for magic state distillation.

8.3 Bugs Finding

Bad Ordering of Syndrome Measurements. In fault-tolerant error correc-
tion, syndrome measurements are repeated multiple times to reliably extract the
syndrome for further error correction. It is worth noting that, we must carefully
design the ordering of syndrome measurements in the repetition. Specifically,
the fault-tolerant method is to perform the full syndrome measurements for all
stabilizers of the QEC and then repeat this process multiple times until we
observe ⌊d/2⌋ + 1 consecutive, all-agree, full syndrome results. In contrast, if
the syndrome measurement for different stabilizers are performed sequentially
— where the repetition is conducted separately for the syndrome measurement
of each stabilizer — then a fault occurring after all repetitions of the a syn-
drome measurement will be unnoticed in that syndrome result. An example of
bad syndrome measurement ordering of the [[7, 1, 3]] color code [8,44] is shown in
Figure 4, where our verification tool identified a fault that will cause a mismatch
between the detected syndrome and the true syndrome, ultimately violating the
fault-tolerance condition.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 21

Repeat:
m1,1 m1,2 m2,1 m2,2 m3,1 m3,2 m4,1 m4,2 m5,1 m5,2 m6,1 m6,2

X X Z Z
X X Z Z X X Z Z
X X Z Z X X Z Z X X Z Z

⇝
X X Z Z X X X Z Z
X X Z Z X X Z Z
X X Z Z
X X Z Z

Until m1,1 = m1,2 ∧ m2,1 = m2,2 ∧ m3,1 = m3,2 ∧ m4,1 = m4,2 ∧ m5,1 = m5,2 ∧ m6,1 = m6,2

Fig. 4: An example of bad syndrome measurement ordering of the color code [8],
where the Pauli measurements are implemented using cat states (see Figure 1b).
A fault is found by our verification tool to witness its non-fault-tolerance.

Lack of Repetition. Consider the implementation of fault-tolerant measure-

ment gadget. Although we can use cat state measurement to “transversally”
perform the multi-qubit Pauli measurement without propagating the errors, the
measurement outcome itself is susceptible to error, i.e., a single fault can flip
the measurement outcome. Therefore, to implement a fault-tolerant measure-
ment, the cat state measurement is performed multiple times, each followed by
an fault-tolerant error correction process on the data qubits. To tolerate up to
t faults, it is enough to repeat it 2t + 1 times and compute the majority of the
outcomes. In contrast, we implement the logical-Z basis measurement of the
[[25, 1, 5]] rotated surface code [7,26] with only 2t = d − 1 = 4 repetitions. Using
our verification tool, we found that two bit-flip faults in the outcomes of the first
and second logical-Z measurements suffice to compromise the final measurement
result, demonstrating its non-fault-tolerance.

References

1. Aaronson, S., Gottesman, D.: Improved simulation of stabilizer circuits. Phys.

Rev. A 70, 052328 (Nov 2004). https://doi.org/10.1103/PhysRevA.70.052328,
https://link.aps.org/doi/10.1103/PhysRevA.70.052328
2. Acharya, R., Aghababaie-Beni, L., Aleiner, I., Andersen, T.I., Ansmann, M., Arute,
F., Arya, K., Asfaw, A., Astrakhantsev, N., Atalaya, J., Babbush, R., Bacon, D.,
Ballard, B., Bardin, J.C., Bausch, J., Bengtsson, A., Bilmes, A., Blackwell, S.,
Boixo, S., Bortoli, G., Bourassa, A., Bovaird, J., Brill, L., Broughton, M., Browne,
D.A., Buchea, B., Buckley, B.B., Buell, D.A., Burger, T., Burkett, B., Bushnell, N.,
Cabrera, A., Campero, J., Chang, H.S., Chen, Y., Chen, Z., Chiaro, B., Chik, D.,
Chou, C., Claes, J., Cleland, A.Y., Cogan, J., Collins, R., Conner, P., Courtney,
W., Crook, A.L., Curtin, B., Das, S., Davies, A., Lorenzo, L.D., Debroy, D.M.,
22 Chen et al.

Demura, S., Devoret, M., Paolo, A.D., Donohoe, P., Drozdov, I., Dunsworth, A.,
Earle, C., Edlich, T., Eickbusch, A., Elbag, A.M., Elzouka, M., Erickson, C., Faoro,
L., Farhi, E., Ferreira, V.S., Burgos, L.F., Forati, E., Fowler, A.G., Foxen, B.,
Ganjam, S., Garcia, G., Gasca, R., Élie Genois, Giang, W., Gidney, C., Gilboa,
D., Gosula, R., Dau, A.G., Graumann, D., Greene, A., Gross, J.A., Habegger, S.,
Hall, J., Hamilton, M.C., Hansen, M., Harrigan, M.P., Harrington, S.D., Heras,
F.J.H., Heslin, S., Heu, P., Higgott, O., Hill, G., Hilton, J., Holland, G., Hong,
S., Huang, H.Y., Huff, A., Huggins, W.J., Ioffe, L.B., Isakov, S.V., Iveland, J.,
Jeffrey, E., Jiang, Z., Jones, C., Jordan, S., Joshi, C., Juhas, P., Kafri, D., Kang,
H., Karamlou, A.H., Kechedzhi, K., Kelly, J., Khaire, T., Khattar, T., Khezri,
M., Kim, S., Klimov, P.V., Klots, A.R., Kobrin, B., Kohli, P., Korotkov, A.N.,
Kostritsa, F., Kothari, R., Kozlovskii, B., Kreikebaum, J.M., Kurilovich, V.D.,
Lacroix, N., Landhuis, D., Lange-Dei, T., Langley, B.W., Laptev, P., Lau, K.M.,
Guevel, L.L., Ledford, J., Lee, K., Lensky, Y.D., Leon, S., Lester, B.J., Li, W.Y.,
Li, Y., Lill, A.T., Liu, W., Livingston, W.P., Locharla, A., Lucero, E., Lundahl, D.,
Lunt, A., Madhuk, S., Malone, F.D., Maloney, A., Mandrá, S., Martin, L.S., Martin,
S., Martin, O., Maxfield, C., McClean, J.R., McEwen, M., Meeks, S., Megrant, A.,
Mi, X., Miao, K.C., Mieszala, A., Molavi, R., Molina, S., Montazeri, S., Morvan, A.,
Movassagh, R., Mruczkiewicz, W., Naaman, O., Neeley, M., Neill, C., Nersisyan,
A., Neven, H., Newman, M., Ng, J.H., Nguyen, A., Nguyen, M., Ni, C.H., O’Brien,
T.E., Oliver, W.D., Opremcak, A., Ottosson, K., Petukhov, A., Pizzuto, A., Platt,
J., Potter, R., Pritchard, O., Pryadko, L.P., Quintana, C., Ramachandran, G.,
Reagor, M.J., Rhodes, D.M., Roberts, G., Rosenberg, E., Rosenfeld, E., Roushan,
P., Rubin, N.C., Saei, N., Sank, D., Sankaragomathi, K., Satzinger, K.J., Schurkus,
H.F., Schuster, C., Senior, A.W., Shearn, M.J., Shorter, A., Shutty, N., Shvarts, V.,
Singh, S., Sivak, V., Skruzny, J., Small, S., Smelyanskiy, V., Smith, W.C., Somma,
R.D., Springer, S., Sterling, G., Strain, D., Suchard, J., Szasz, A., Sztein, A., Thor,
D., Torres, A., Torunbalci, M.M., Vaishnav, A., Vargas, J., Vdovichev, S., Vidal,
G., Villalonga, B., Heidweiller, C.V., Waltman, S., Wang, S.X., Ware, B., Weber,
K., White, T., Wong, K., Woo, B.W.K., Xing, C., Yao, Z.J., Yeh, P., Ying, B., Yoo,
J., Yosri, N., Young, G., Zalcman, A., Zhang, Y., Zhu, N., Zobrist, N.: Quantum
error correction below the surface code threshold. arXiv preprint arXiv:2408.13687
(2024)
3. Acharya, R., Aleiner, I., Allen, R., Andersen, T.I., Ansmann, M., Arute, F., Arya,
K., Asfaw, A., Atalaya, J., Babbush, R., Bacon, D., Bardin, J.C., Basso, J., Bengts-
son, A., Boixo, S., Bortoli, G., Bourassa, A., Bovaird, J., Brill, L., Broughton, M.,
Buckley, B.B., Buell, D.A., Burger, T., Burkett, B., Bushnell, N., Chen, Y., Chen,
Z., Chiaro, B., Cogan, J., Collins, R., Conner, P., Courtney, W., Crook, A.L.,
Curtin, B., Debroy, D.M., Barba, A.D.T., Demura, S., Dunsworth, A., Eppens,
D., Erickson, C., Faoro, L., Farhi, E., Fatemi, R., Burgos, L.F., Forati, E., Fowler,
A.G., Foxen, B., Giang, W., Gidney, C., Gilboa, D., Giustina, M., Dau, A.G.,
Gross, J.A., Habegger, S., Hamilton, M.C., Harrigan, M.P., Harrington, S.D., Hig-
gott, O., Hilton, J., Hoffmann, M., Hong, S., Huang, T., Huff, A., Huggins, W.J.,
Ioffe, L.B., Isakov, S.V., Iveland, J., Jeffrey, E., Jiang, Z., Jones, C., Juhas, P.,
Kafri, D., Kechedzhi, K., Kelly, J., Khattar, T., Khezri, M., Kieferová, M., Kim,
S., Kitaev, A., Klimov, P.V., Klots, A.R., Korotkov, A.N., Kostritsa, F., Kreike-
baum, J.M., Landhuis, D., Laptev, P., Lau, K.M., Laws, L., Lee, J., Lee, K., Lester,
B.J., Lill, A., Liu, W., Locharla, A., Lucero, E., Malone, F.D., Marshall, J., Mar-
tin, O., McClean, J.R., Mccourt, T., McEwen, M., Megrant, A., Costa, B.M., Mi,
X., Miao, K.C., Mohseni, M., Montazeri, S., Morvan, A., Mount, E., Mruczkiewicz,
 Verifying Fault-Tolerance of Quantum Error Correction Codes 23

W., Naaman, O., Neeley, M., Neill, C., Nersisyan, A., Neven, H., Newman, M., Ng,
J.H., Nguyen, A., Nguyen, M., Niu, M.Y., O’Brien, T.E., Opremcak, A., Platt, J.,
Petukhov, A., Potter, R., Pryadko, L.P., Quintana, C., Roushan, P., Rubin, N.C.,
Saei, N., Sank, D., Sankaragomathi, K., Satzinger, K.J., Schurkus, H.F., Schuster,
C., Shearn, M.J., Shorter, A., Shvarts, V., Skruzny, J., Smelyanskiy, V., Smith,
W.C., Sterling, G., Strain, D., Szalay, M., Torres, A., Vidal, G., Villalonga, B.,
Heidweiller, C.V., White, T., Xing, C., Yao, Z.J., Yeh, P., Yoo, J., Young, G.,
Zalcman, A., Zhang, Y., Zhu, N.: Suppressing quantum errors by scaling a surface
code logical qubit. Nature 614(7949), 676–681 (2023)
4. Bauer-Marquart, F., Leue, S., Schilling, C.: symqv: automated symbolic verification
of quantum programs. In: International Symposium on Formal Methods. pp. 181–
198. Springer (2023)
5. Bezanson, J., Edelman, A., Karpinski, S., Shah, V.B.: Julia: A fresh approach to
numerical computing. SIAM review 59(1), 65–98 (2017)
6. Bluvstein, D., Evered, S.J., Geim, A.A., Li, S.H., Zhou, H., Manovitz, T., Ebadi, S.,
Cain, M., Kalinowski, M., Hangleiter, D., Bonilla Ataides, J.P., Maskara, N., Cong,
I., Gao, X., Sales Rodriguez, P., Karolyshyn, T., Semeghini, G., Gullans, M.J.,
Greiner, M., Vuletić, V., Lukin, M.D.: Logical quantum processor based on recon-
figurable atom arrays. Nature 626(7997), 58–65 (Dec 2023). https://doi.org/10.
1038/s41586-023-06927-3, http://dx.doi.org/10.1038/s41586-023-06927-3
7. Bombín, H., Martin-Delgado, M.A.: Optimal resources for topological two-
dimensional stabilizer codes: Comparative study. Physical Review A—Atomic,
Molecular, and Optical Physics 76(1), 012305 (2007)
8. Bombin, H., Martin-Delgado, M.A.: Topological quantum distillation. Physical re-
view letters 97(18), 180501 (2006)
9. Bravyi, S., Kitaev, A.: Universal quantum computation with ideal clifford gates
and noisy ancillas. Physical Review A—Atomic, Molecular, and Optical Physics
71(2), 022316 (2005)
10. Breuckmann, N.P., Eberhardt, J.N.: Quantum low-density parity-check codes.
PRX Quantum 2(4) (Oct 2021). https://doi.org/10.1103/prxquantum.2.
040101, http://dx.doi.org/10.1103/PRXQuantum.2.040101
11. Burgholzer, L., Wille, R.: Advanced equivalence checking for quantum circuits.
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
40(9), 1810–1824 (Sep 2021). https://doi.org/10.1109/tcad.2020.3032630,
http://dx.doi.org/10.1109/TCAD.2020.3032630
12. Burgholzer, L., Wille, R.: Handling non-unitaries in quantum circuit equivalence
checking. In: Proceedings of the 59th ACM/IEEE Design Automation Conference.
DAC ’22, ACM (Jul 2022). https://doi.org/10.1145/3489517.3530482, http:
//dx.doi.org/10.1145/3489517.3530482
13. Chen, J.S., Nielsen, E., Ebert, M., Inlek, V., Wright, K., Chaplin, V.,
Maksymov, A., Páez, E., Poudel, A., Maunz, P., Gamble, J.: Benchmark-
ing a trapped-ion quantum computer with 30 qubits. Quantum 8, 1516
(Nov 2024). https://doi.org/10.22331/q-2024-11-07-1516, http://dx.doi.
org/10.22331/q-2024-11-07-1516
14. Chen, K., Ying, M.: Automatic test pattern generation for robust quantum circuit
testing. ACM Transactions on Design Automation of Electronic Systems 29(6),
1–36 (2024)
15. Fang, W., Ying, M.: Symbolic execution for quantum error correction programs.
Proceedings of the ACM on Programming Languages 8(PLDI), 1040–1065 (2024)
24 Chen et al.

16. Fang, W., Ying, M.: Symphase: Phase symbolization for fast simulation of stabilizer
circuits. In: Proceedings of the 61st ACM/IEEE Design Automation Conference.
pp. 1–6 (2024)
17. Farrell, R.C., Illa, M., Ciavarella, A.N., Savage, M.J.: Scalable circuits for preparing
ground states on digital quantum computers: The schwinger model vacuum on 100
qubits. PRX Quantum 5(2), 020315 (2024)
18. Feng, Y., Ying, M.: Quantum hoare logic with classical variables. ACM Transac-
tions on Quantum Computing 2(4), 1–43 (Dec 2021). https://doi.org/10.1145/
3456877, http://dx.doi.org/10.1145/3456877
19. Gidney, C.: Stim: a fast stabilizer circuit simulator. Quantum 5, 497 (Jul 2021).
https://doi.org/10.22331/q-2021-07-06-497, http://dx.doi.org/10.22331/
q-2021-07-06-497
20. Gottesman, D.: Stabilizer codes and quantum error correction. California Institute
of Technology (1997)
21. Gottesman, D.: The heisenberg representation of quantum computers. arXiv
preprint quant-ph/9807006 (1998)
22. Gottesman, D.: An introduction to quantum error correction and fault-tolerant
quantum computation. In: Quantum information science and its contributions to
mathematics, Proceedings of Symposia in Applied Mathematics. vol. 68, pp. 13–58
(2010)
23. Gottesman, D.: Surviving as a quantum computer in a classical world. Textbook
manuscript preprint (2024)
24. Guan, J., Feng, Y., Turrini, A., Ying, M.: Measurement-based verification of quan-
tum markov chains. In: International Conference on Computer Aided Verification.
pp. 533–554. Springer (2024)
25. Hong, X., Ying, M., Feng, Y., Zhou, X., Li, S.: Approximate equivalence checking of
noisy quantum circuits. In: 2021 58th ACM/IEEE Design Automation Conference
(DAC). pp. 637–642. IEEE (2021)
26. Horsman, D., Fowler, A.G., Devitt, S., Van Meter, R.: Surface code quantum com-
puting by lattice surgery. New Journal of Physics 14(12), 123011 (2012)
27. Hung, S.H., Hietala, K., Zhu, S., Ying, M., Hicks, M., Wu, X.: Quantitative ro-
bustness analysis of quantum programs. Proceedings of the ACM on Programming
Languages 3(POPL), 1–29 (2019)
28. Hung, S.H., Peng, Y., Wang, X., Zhu, S., Wu, X.: On the theory and prac-
tice of invariant-based verification of quantum programs (2019), https://api.
semanticscholar.org/CorpusID:208634831
29. King, J.C.: Symbolic execution and program testing. Communications of the ACM
19(7), 385–394 (1976)
30. Kitaev, A.: Fault-tolerant quantum computation by anyons. Annals of Physics
303(1), 2–30 (Jan 2003). https://doi.org/10.1016/s0003-4916(02)00018-0,
http://dx.doi.org/10.1016/S0003-4916(02)00018-0
31. Knill, E.: Fault-tolerant postselected quantum computation: Schemes. arXiv
preprint quant-ph/0402171 (2004)
32. Leverrier, A., Zémor, G.: Quantum tanner codes. In: 2022 IEEE 63rd Annual Sym-
posium on Foundations of Computer Science (FOCS). pp. 872–883. IEEE (2022)
33. Li, G., Zhou, L., Yu, N., Ding, Y., Ying, M., Xie, Y.: Projection-based runtime
assertions for testing and debugging quantum programs. Proceedings of the ACM
on Programming Languages 4(OOPSLA), 1–29 (2020)
34. Liu, J., Zhan, B., Wang, S., Ying, S., Liu, T., Li, Y., Ying, M., Zhan, N.:
Formal Verification of Quantum Algorithms Using Quantum Hoare Logic, pp.
 Verifying Fault-Tolerance of Quantum Error Correction Codes 25

187–207. Computer Aided Verification (07 2019). https://doi.org/10.1007/

978-3-030-25543-5_12
35. Manetsch, H.J., Nomura, G., Bataille, E., Leung, K.H., Lv, X., Endres, M.:
A tweezer array with 6100 highly coherent atomic qubits. arXiv preprint
arXiv:2403.12021 (2024)
36. Nan, J., Zichen, W., Jian, W.: Quantum symbolic execution. Quantum In-
formation Processing 22(10), 389 (Oct 2023). https://doi.org/10.1007/
s11128-023-04144-5, https://doi.org/10.1007/s11128-023-04144-5
37. Nebe, G., Rains, E.M., Sloane, N.J.: The invariants of the clifford groups. Designs,
Codes and Cryptography 24(1), 99–122 (2001)
38. Nielsen, M.A., Chuang, I.L.: Quantum Computation and Quantum Information:
10th Anniversary Edition. Cambridge University Press (2010). https://doi.org/
10.1017/CBO9780511976667, http://dx.doi.org/10.1017/CBO9780511976667
39. Niemetz, A., Preiner, M.: Bitwuzla. In: Enea, C., Lal, A. (eds.) Computer Aided
Verification - 35th International Conference, CAV 2023, Paris, France, July 17-22,
2023, Proceedings, Part II. Lecture Notes in Computer Science, vol. 13965, pp.
3–17. Springer (2023). https://doi.org/10.1007/978-3-031-37703-7_1, https:
//doi.org/10.1007/978-3-031-37703-7_1
40. Peham, T., Burgholzer, L., Wille, R.: Equivalence checking of quantum circuits
with the zx-calculus. IEEE Journal on Emerging and Selected Topics in Cir-
cuits and Systems 12(3), 662–675 (2022). https://doi.org/10.1109/JETCAS.
2022.3202204
41. Peham, T., Burgholzer, L., Wille, R.: Equivalence checking of parameterized quan-
tum circuits: Verifying the compilation of variational quantum algorithms. In:
Proceedings of the 28th Asia and South Pacific Design Automation Conference.
p. 702–708. ASPDAC ’23, Association for Computing Machinery, New York, NY,
USA (2023). https://doi.org/10.1145/3566097.3567932, https://doi.org/10.
1145/3566097.3567932
42. Preskill, J.: Quantum computing 40 years later. In: Feynman Lectures on Compu-
tation, pp. 193–244. CRC Press (2023)
43. Reichardt, B.W., Paetznick, A., Aasen, D., Basov, I., Bello-Rivas, J.M., Bonderson,
P., Chao, R., van Dam, W., Hastings, M.B., Paz, A., da Silva, M.P., Sundaram, A.,
Svore, K.M., Vaschillo, A., Wang, Z., Zanner, M., Cairncross, W.B., Chen, C.A.,
Crow, D., Kim, H., Kindem, J.M., King, J., McDonald, M., Norcia, M.A., Ryou,
A., Stone, M., Wadleigh, L., Barnes, K., Battaglino, P., Bohdanowicz, T.C., Booth,
G., Brown, A., Brown, M.O., Cassella, K., Coxe, R., Epstein, J.M., Feldkamp, M.,
Griger, C., Halperin, E., Heinz, A., Hummel, F., Jaffe, M., Jones, A.M.W., Kapit,
E., Kotru, K., Lauigan, J., Li, M., Marjanovic, J., Megidish, E., Meredith, M.,
Morshead, R., Muniz, J.A., Narayanaswami, S., Nishiguchi, C., Paule, T., Pawlak,
K.A., Pudenz, K.L., Pérez, D.R., Simon, J., Smull, A., Stack, D., Urbanek, M.,
van de Veerdonk, R.J.M., Vendeiro, Z., Weverka, R.T., Wilkason, T., Wu, T.Y.,
Xie, X., Zalys-Geller, E., Zhang, X., Bloom, B.J.: Logical computation demon-
strated with a neutral atom quantum processor. arXiv preprint arXiv:2411.11822
(2024)
44. Rodriguez, P.S., Robinson, J.M., Jepsen, P.N., He, Z., Duckering, C., Zhao, C.,
Wu, K.H., Campo, J., Bagnall, K., Kwon, M., et al.: Experimental demonstration
of logical magic state distillation. arXiv preprint arXiv:2412.15165 (2024)
45. Sawicki, A., Karnas, K.: Universality of single-qudit gates. In: Annales Henri
Poincaré. vol. 18, pp. 3515–3552. Springer (2017)
26 Chen et al.

46. Shi, Y., Tao, R., Li, X., Javadi-Abhari, A., Cross, A.W., Chong, F.T., Gu, R.:
Certiq: a mostly-automated verification of a realistic quantum compiler. arXiv
preprint arXiv:1908.08963 (2019)
47. Shor, P.W.: Fault-tolerant quantum computation. In: Proceedings of 37th confer-
ence on foundations of computer science. pp. 56–65. IEEE (1996)
48. Smith, K.N., Perlin, M.A., Gokhale, P., Frederick, P., Owusu-Antwi, D., Rines, R.,
Omole, V., Chong, F.: Clifford-based circuit cutting for quantum simulation. In:
Proceedings of the 50th Annual International Symposium on Computer Architec-
ture. pp. 1–13 (2023)
49. Steane, A.M.: Quantum reed-muller codes. IEEE Transactions on Information The-
ory 45(5), 1701–1703 (1999)
50. Tao, R., Shi, Y., Yao, J., Hui, J., Chong, F.T., Gu, R.: Gleipnir: toward prac-
tical error analysis for quantum programs. In: Proceedings of the 42nd ACM
SIGPLAN International Conference on Programming Language Design and Im-
plementation. p. 48–64. PLDI 2021, Association for Computing Machinery, New
York, NY, USA (2021). https://doi.org/10.1145/3453483.3454029, https://
doi.org/10.1145/3453483.3454029
51. Tao, R., Shi, Y., Yao, J., Li, X., Javadi-Abhari, A., Cross, A.W., Chong, F.T.,
Gu, R.: Giallar: Push-button verification for the qiskit quantum compiler. In: Pro-
ceedings of the 43rd ACM SIGPLAN International Conference on Programming
Language Design and Implementation. p. 641–656. PLDI 2022, Association for
Computing Machinery, New York, NY, USA (2022). https://doi.org/10.1145/
3519939.3523431, https://doi.org/10.1145/3519939.3523431
52. Wang, Q., Li, R., Ying, M.: Equivalence checking of sequential quantum circuits.
IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems
41(9), 3143–3156 (2022). https://doi.org/10.1109/TCAD.2021.3117506
53. Ying, M.: Floyd–hoare logic for quantum programs. ACM Transactions on Pro-
gramming Languages and Systems (TOPLAS) 33(6), 1–49 (2012)
54. Ying, M.: A practical quantum hoare logic with classical variables, i. arXiv preprint
arXiv:2412.09869 (2024)
55. Ying, M., Feng, Y.: A flowchart language for quantum programming. IEEE Trans-
actions on Software Engineering 37(4), 466–485 (2010)
56. Ying, M., Ying, S., Wu, X.: Invariants of quantum programs: Characterisations
and generation. In: Proceedings of the 44th ACM SIGPLAN Symposium on Prin-
ciples of Programming Languages. p. 818–832. POPL ’17, Association for Comput-
ing Machinery, New York, NY, USA (2017). https://doi.org/10.1145/3009837.
3009840, https://doi.org/10.1145/3009837.3009840
57. Zhou, L., Barthe, G., Strub, P.Y., Liu, J., Ying, M.: Coqq: Foundational verification
of quantum programs. Proc. ACM Program. Lang. 7(POPL) (jan 2023). https:
//doi.org/10.1145/3571222, https://doi.org/10.1145/3571222