betaFeedback

WorksPhysics and Astronomy

Verified Pauli-Product Measurement Compilation for Fault-Tolerant Quantum Computation

Abstract

Fault-tolerant quantum compilers implement gates through Pauli-product measurements and classical feedback. Verifying such a compiler requires reasoning about the quantum state and the recorded outcomes together: a correction reads an outcome, a gate's internal outcomes must be hidden from its caller, and an application's outcomes must survive optimization. We introduce QPPM, a language for Pauli-product measurement programs, with a weakest-precondition semantics over store-indexed matrix assertions, following quantum Hoare logic with classical variables. Every program terminates, so the Hoare logic is a syntactic presentation of weakest preconditions whose soundness and relative completeness are immediate. Its value is that component specifications compose. All results are mechanized in Lean. We verify lowering of Clifford+TT circuits to QPPM with private outcomes and supplied magic states, and an optimizer that eliminates measurements, fuses and reorders rotations, and schedules logical rounds while preserving every outcome that subsequent code can read. A compositional approximation relation bounds the effect of synthesis error on specifications and on output trace distance, and a certificate-checked pipeline selects, among synthesized circuits that meet the user's error limit, the one with the lowest certified depth bound. On QASMBench, verified fusion and scheduling reduce logical measurement depth by a median of 17.9%, and complete source-to-QPPM allowances are certified for all 35 valid selected small-suite inputs.

CCS Concepts: • Theory of computation → Program verification. • Software and its engineering → Compilers.

Introduction

Fault-tolerant quantum computation encodes logical qubits in quantum error-correcting codes. A compiler must translate an algorithm’s gates into operations on these encoded qubits. For surface codes, lattice surgery implements logical gates through joint Pauli measurements [20, 24]. This measurement interface also extends to quantum low-density parity-check (qLDPC) codes.

Code-surgery constructions for qLDPC codes support logical Pauli-product measurements (PPMs) [9, 32], including joint measurements across code blocks [12] and parallel measurements on logically disjoint sets of qubits [11]. Despite different connectivity requirements and physical costs, these constructions share a logical measurement interface.

This interface already connects algorithms to proposed architectures. Cain et al. [2026] estimate the resources for Shor’s algorithm, including RSA−2048 factorization, on neutral-atom architectures using lifted-product codes. In their compilation strategy, PPMs serve as an intermediate representation: Clifford gates are absorbed into the measured Pauli operators, and code surgery implements the measurements. Their time-efficient estimates assume parallel code surgery for layers of logically disjoint PPMs. This use of PPMs motivates the interface in Figure 1.

Compilation stages diagram showing source circuit rotations and readouts, Clifford+$T$ circuit, QPPM program, magic states and ideal inputs, and code surgery

Figure 1. Compilation stages. Synthesis error is certified per input, lowering to QPPM is verified under explicit magic-state assumptions, and exact transformations preserve the public specifications. Algorithm 1 specifies the solid arrows. The dashed stage is code-specific physical mapping.

Existing lattice-surgery compilers translate circuits into measurement instructions [31] (LeBlond et al. 2024). They do not provide a machine-checked proof of that translation preserves an algorithm’s behavior, leaving a gap between algorithm verification and error-correcting

Authors’ addresses: John Zhuoyang Ye, University of California Los Angeles, Los Angeles, USA, [email protected]. Jens Palsberg, University of California Los Angeles, Los Angeles, USA, [email protected]. implementations. Such a proof must cover both quantum outputs and classical outcomes: a correction reads a measurement result, a gate’s private outcomes must be hidden from its caller, and public outcomes must survive optimization.

We formalize this measurement interface in QPPM, a language for Pauli-product measurements and classical feedback. Its Hoare logic composes specifications according to program structure: a verified phase-gate specification can be reused without expanding the gate’s internal measurements.

Quantum Hoare logic interprets assertions as matrices whose expectations describe quantum states [34]. Following Feng and Ying [ [15], these matrices depend on the classical store. An assertion can relate a measurement’s output state to its recorded outcome. Sequencing (H-Seq) connects that specification to a later correction. We prove soundness and relative completeness for QPPM’s weakest-precondition semantics. A forward semantics gives the output states and their probabilities.

Compiled-gate specifications hide private outcomes by summing over their possible values. Optimizations preserve the outcomes available to a continuation. We verify measurement elimination and rotation scheduling under these respective conditions.

Approximate synthesis changes a program’s behavior. We bound the change in the expectation of every effect, a matrix predicate whose expectation lies between zero and one. These bounds compose: replacing a command with allowance ε\varepsilon lowers its Hoare guarantee by at most ε\varepsilon. Our compiler checks a finite collection of Clifford+TT approximations and, among those meeting the user’s error limit, selects the implementation with the smallest certified measurement-depth bound (§ 8.1).

Our contributions are:

  1. We define QPPM and prove a sound and relatively complete Hoare logic for its measurements, classical control, and scoped ancillas (§ 3–§ 4).

  1. We verify compilation into QPPM and optimizations that preserve public quantum outputs and measurement results. Worked derivations show how their specifications compose (§ 5–§ 6).

  1. We prove compositional approximation bounds and their connection to Hoare specifications and classical–quantum trace distance. A separate implementation contract adds logical-noise bounds without extending the core calculus (§ 7).

We mechanize these results in Lean and evaluate them on QASMBench. Verified fusion and scheduling reduce logical measurement depth by 11.8–28.6% in six of eight Clifford circuits, against a parallel baseline with matched ancilla resources. Our proofs concern typed source circuits and ideal logical measurements. Physical mapping and decoding remain outside their scope.

Background and compilation overview

Pauli-product measurements

A qubit has basis states ∣0⟩\lvert0\rangle and ∣1⟩\lvert1\rangle, and an nn-qubit register has basis vectors indexed by nn-bit strings.

We use density matrices to include probabilistic mixtures: a state ρ\rho is a positive semidefinite 2n×2n2^n \times2^n complex matrix with tr⁡(ρ)=1\operatorname{tr}(\rho)=1, a pure state ∣ψ⟩\lvert\psi\rangle has density matrix ∣ψ⟩⟨ψ∣\lvert\psi\rangle\langle\psi\rvert, and a unitary gate UU acts as ρ↦UρU†\rho\mapsto U\rho U^\dagger, where †\dagger denotes conjugate transpose.

The Pauli matrices are

I=(1001),X=(0110),Y=(0−ii0),Z=(100−1).I=\begin{pmatrix}1&0\\0&1\end{pmatrix},\quad X=\begin{pmatrix}0&1\\1&0\end{pmatrix},\quad Y=\begin{pmatrix}0&-i\\i&0\end{pmatrix},\quad Z=\begin{pmatrix}1&0\\0&-1\end{pmatrix}.

We form a signed Pauli product P=(−1)ηP1⊗⋯⊗PnP=(-1)^\eta P_1\otimes\cdots\otimes P_n by choosing a sign bit η\eta and one Pauli matrix for each qubit. The tensor product ⊗\otimes places these operators on their respective qubits. An II factor leaves a qubit unchanged. Since PP is Hermitian and P2=IP^2=I, its possible measurement outcomes are +1+1 and −1-1. We encode them by a bit bb, with eigenvalue (−1)b(-1)^b.

Figure 2 illustrates a measurement of Z⊗ZZ\otimes Z, which returns the parity of two qubits in the computational basis: outcome zero selects the span of ∣00⟩,∣11⟩\lvert00\rangle,\lvert11\rangle and outcome one the span of ∣01⟩,∣10⟩\lvert01\rangle,\lvert10\rangle, preserving superpositions within the selected subspace, whereas measuring each qubit separately would destroy such coherence. We write r:=measure⁡Pr:=\operatorname{measure} P for measuring PP and recording its outcome in rr. The column in the figure denotes one joint measurement with one result bit. Both quantum wires remain available afterwards. Lattice surgery implements such measurements on encoded qubits [24].

Measurement of $Z\otimes Z$ on input qubits $q_0$ and $q_1$, with result bit $r$ and Pauli factors $X$, $Y$, $Z$, and $I$

Figure 2. Input qubits q0q_0, q1q_1 and classical location rr. One outlined column denotes one joint measurement. In all circuit figures, orange, purple, and blue identify XX, YY, ZZ. Gray denotes II. A meter marks a measurement. The quantum wires continue after the measurement, while the double line carries its classical result.

For a product PP, define the projectors

Π0P=I+P2,Π1P=I−P2.\Pi^P_0=\frac{I+P}{2},\qquad\Pi^P_1=\frac{I-P}{2}.

The output associated with bit bb is ΠbPρΠbP\Pi^P_b\rho\Pi^P_b, and its trace gives the probability of that outcome. We retain this unnormalized matrix throughout the semantics: it records the probability and the quantum state in one object. The projectors satisfy

(ΠbP)†=ΠbP,(ΠbP)2=ΠbP,Π0PΠ1P=Π1PΠ0P=0,Π0P+Π1P=I.(1)(\Pi^P_b)^\dagger=\Pi^P_b,\qquad(\Pi^P_b)^2=\Pi^P_b,\qquad\Pi^P_0\Pi^P_1=\Pi^P_1\Pi^P_0=0,\qquad\Pi^P_0+\Pi^P_1=I. \tag*{(1)}

We prove these identities from the Pauli matrices and use them in the measurement and optimization proofs.

Classical feedback and gate compilation

A measurement program can read a stored outcome to choose a correction. In a gate implementation, these corrections make the output implement the required gate after summing over internal outcomes. Results returned to the caller must remain distinguishable.

We use the phase gate S=diag⁡(1,i)S = \operatorname{diag}(1, i) as a running example. Consider an application that measures XX, applies SS, and then measures YY. Since SXS†=YS X S^\dagger= Y, the two measurements return the same bit. We verify this property after replacing SS by measurements and feedback. The application reads its initial and final results. The gate implementation’s outcomes stay private.

To specify this property, we use assertions that relate a stored bit to a quantum eigenspace, following Feng and Ying [ [15]. § 4.1 composes the two measurement specifications with the compiled phase gate’s specification.

The Clifford gates HH, SS, CNOT map Pauli products to Pauli products by conjugation. Adding T=diag⁡(1,eiπ/4)T = \operatorname{diag}(1, e^{i\pi/4}) permits approximation of arbitrary single-qubit rotations Ross and Selinger [ [27].

When synthesis approximates a source rotation, we bound the change in observable probabilities. § 7 composes these bounds along a circuit and transfers its Hoare specification to the approximate implementation.

QPPM: syntax and semantics

Syntax

A QPPM command c∈Cn,mc \in\mathcal{C}_{n,m} operates on nn data qubits and mm classical bits. Its input and output registers have the same widths. Temporary qubits are introduced by an ancilla scope. The syntax and metatheory are parameterized by nn and mm:

e::=0∣1∣read⁡ r∣¬e∣e⊕e,c::=skip⁡∣r:=e∣r:=measure⁡ P∣correct⁡ P∣c▹c∣if⁡ e then⁡ c else⁡ c∣let⁡ ν=ancilla⁡ ∣b⟩ in⁡ c.\begin{aligned} e &::= 0 \mid1 \mid\operatorname{read}\ r \mid\neg e \mid e \mathbin{\oplus} e,\\ c &::= \operatorname{skip} \mid r := e \mid r := \operatorname{measure}\ P \mid\operatorname{correct}\ P\\ &\quad\mid c \mathbin{\triangleright} c \mid\operatorname{if}\ e\ \operatorname{then}\ c\ \operatorname{else}\ c\\ &\quad\mid\operatorname{let}\ \nu= \operatorname{ancilla}\ \lvert b\rangle\ \operatorname{in}\ c. \end{aligned}

Here ee is a Boolean expression, rr is a bit position, and b∈{0,1}b \in\{0, 1\} is an initialization value. The operator ⊕\oplus denotes exclusive-or. The product PP contains one Pauli factor for each qubit in the current register. The correction command applies PP by conjugation. The sequence c▹dc \mathbin{\triangleright} d executes cc then dd. Programs have declared input contexts Γ=(q0,…,qn−1)\Gamma= (q_0, \ldots, q_{n-1}) for qubits and Δ=(r0,…,rm−1)\Delta= (r_0, \ldots, r_{m-1}) for classical locations, with distinct names in each. These ordered lists name register positions, and ()() denotes an empty register. Every qubit reference must belong to the current Γ\Gamma, and every bit read or write must refer to Δ\Delta. Measurement overwrites a declared location rather than allocating one. The caller supplies the input state and initial classical values. A scope binds a fresh name ν∉Γ\nu\notin\Gamma to a first qubit prepared in ∣b⟩\lvert b\rangle, executes its body in Cn+1,m\mathcal{C}_{n+1,m} with context (ν,Γ)(\nu,\Gamma), and discards ν\nu. Existing qubits keep their names and move up one position inside the scope. The name ν\nu is local to the body. Classical writes remain available afterwards. On a one-qubit register we omit the qubit subscript. Unmentioned tensor factors are II.

We abbreviate r:=measure⁡ Pr := \operatorname{measure}\ P by MP(r)M_P(r) and read rr by rr in guards and assignments. Figure 3 uses these commands to reset a qubit to ∣0⟩\lvert0\rangle while returning a copy of the measurement record. Measurement supplies the record. The conditional applies a correction only to outcome one. Assignment makes the copy. We use this same program for the backward, forward, and Hoare derivations below.

Circuit for measuring $Z$, correcting outcome 1, and copying the result

Figure 3. Inputs: Γ=(q)\Gamma= (q), Δ=(r,u)\Delta= (r,u). Measure ZZ, correct outcome 1, and copy the result. The double wire carries rr to the correction and assignment. When r=0r = 0, the data wire passes through unchanged.

Assertions and weakest preconditions

A classical store ss maps the mm bit positions to Boolean values. We use assertions AA that map each store to a Hermitian matrix on the quantum register. For a quantum state ρ\rho, the value tr⁡(ρA(s))\operatorname{tr}(\rho A(s)) is its expectation. An effect satisfies 0⪯A(s)⪯I0 \preceq A(s) \preceq I for every store, so this expectation lies between zero and one on normalized states. The mechanization admits arbitrary complex matrices, which is convenient for intermediate calculations. Every assertion in this paper is Hermitian.

The classical locations of a program are divided into public bits, which the caller may read, and private bits, which a component uses for its internal measurement outcomes. Let π\pi map a store to its public part. A public assertion has the form A∘πA \circ\pi: it ignores the private bits. The contracts of § 5 are stated for public assertions, so that a compiled gate’s internal outcomes are hidden from its caller, whereas the optimizer of § 6 compares assertions on the full store because the continuation may read any retained bit.

Two forms recur. A classical event EE gives the effect [E][E], with [E](s)=I[E](s) = I if E(s)E(s) holds and 00 otherwise, whose expected value on a program output is the probability of EE. A quantum property that depends on a measurement result uses A(s)=Πs(r)PA(s) = \Pi_{s(r)}^{P}: expectation one states that the output lies in the eigenspace recorded in rr, and multiplying by [s(u)=s(r)][s(u) = s(r)] also requires two result bits to agree. Both forms appear in the reset and phase-gate examples.

In the Löwner order, A⊑BA \sqsubseteq B means that B(s)−A(s)B(s) - A(s) is positive semidefinite for every store ss. This order compares expectations on all positive states. Effects are the assertions used for probability and approximation allowances.

We define wp⁡(c,A)\operatorname{wp}(c,A) by reasoning backwards from the postcondition AA through cc: assignment substitutes the new bit value into AA, measurement performs this substitution for each outcome and applies the corresponding projectors, and an ancilla scope ignores the temporary qubit in the postcondition and assumes its initial state in the precondition.

Write s[r↦b]s[r \mapsto b] for the store obtained by updating bit rr to bb. Let EbE_b be the inclusion ∣ψ⟩↦∣b⟩⊗∣ψ⟩\lvert\psi\rangle\mapsto\lvert b\rangle\otimes\lvert\psi\rangle. Write prep⁡b∗(A)=Eb†AEb\operatorname{prep}^{*}_{b}(A) = E_b^{\dagger} A E_b and drop⁡∗(B)=∑j=01EjBEj†=I2⊗B\operatorname{drop}^{*}(B) = \sum_{j=0}^{1} E_j B E_j^{\dagger} = I_2 \otimes B, acting pointwise on assertions. The weakest-precondition equations are:

wp⁡(skip⁡,A)=A\operatorname{wp}(\operatorname{skip}, A) = A
wp⁡(r:=e,A)(s)=A(s[r↦e(s)])\operatorname{wp}(r := e, A)(s) = A(s[r \mapsto e(s)])
wp⁡(correct⁡ P,A)(s)=PA(s)P\operatorname{wp}(\operatorname{correct}\ P, A)(s) = P A(s) P
wp⁡(c▹d,A)=wp⁡(c,wp⁡(d,A))\operatorname{wp}(c \mathbin{\triangleright} d, A) = \operatorname{wp}(c,\operatorname{wp}(d,A))
wp⁡(MP(r),A)(s)=∑j=01ΠjPA(s[r↦j])ΠjP\operatorname{wp}(M_P(r),A)(s) = \sum_{j=0}^{1} \Pi_j^P A(s[r \mapsto j]) \Pi_j^P
wp⁡(if⁡ e then⁡ c else⁡ d,A)(s)={wp⁡(c,A)(s)e(s)=1,wp⁡(d,A)(s)e(s)=0,\operatorname{wp}(\operatorname{if}\ e\ \operatorname{then}\ c\ \operatorname{else}\ d,A)(s) = \begin{cases} \operatorname{wp}(c,A)(s) & e(s) = 1,\\ \operatorname{wp}(d,A)(s) & e(s) = 0, \end{cases}
wp⁡(let⁡ v=ancilla⁡ ∣b⟩ in⁡ c,A)=prep⁡b∗(wp⁡(c,drop⁡∗(A))).\operatorname{wp}(\operatorname{let}\ v = \operatorname{ancilla}\ \lvert b\rangle\ \operatorname{in}\ c,A) = \operatorname{prep}^{*}_{b}(\operatorname{wp}(c,\operatorname{drop}^{*}(A))).

We prove that wp⁡\operatorname{wp} is linear and monotone, that wp⁡(c,I)=I\operatorname{wp}(c,I)=I, and that it maps effects to effects. These properties justify H-Cons and the approximation rules of Theorem 4.

Example: calculate the reset precondition. For the program in Figure 3, set

References

  1. [1]Matthew Amy, Dmitri Maslov, and Michele Mosca. 2014. Polynomial-Time T-Depth Optimization of Clifford+T Circuits Via Matroid Partitioning. IEEE Transactions on Computer-Aided Design of Integrated Circuits and Systems 33, 10 (2014), 1476–1489. https://doi.org/10.1109/TCAD.2014.2341953
  2. [2]Gilles Barthe, Justin Hsu, Mingsheng Ying, Nengkun Yu, and Li Zhou. 2020. Relational proofs for quantum programs. Proceedings of the ACM on Programming Languages 4, POPL, Article 21 (2020), 29 pages. https://doi.org/10.1145/3371089
  3. [3]Michael Beverland, Vadym Kliuchnikov, and Eddie Schoute. 2022. Surface Code Compilation via Edge-Disjoint Paths. PRX Quantum 3 (2022), 020342. https://doi.org/10.1103/PRXQuantum.3.020342
  4. [4]Robert I. Booth and Cole Comfort. 2026. Denotational Semantics for Stabiliser Quantum Programs. In 11th International Conference on Formal Structures for Computation and Deduction (FSCD 2026) (Leibniz International Proceedings in Informatics, Vol. 378), Frank Pfenning (Ed.). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, Dagstuhl, Germany, 8:1–8:24. https://doi.org/10.4230/LIPIcs.FSCD.2026.8
  5. [5]P. Oscar Boykin, Tal Mor, Matthew Pulver, Vwani Roychowdhury, and Farokh Vatan. 1999. On Universal and Fault-Tolerant Quantum Computing. arXiv:quant-ph/9906054 https://arxiv.org/abs/quant-ph/9906054
  6. [6]Sergey Bravyi, Graeme Smith, and John A. Smolin. 2016. Trading Classical and Quantum Computational Resources. Physical Review X 6 (2016), 021043. https://doi.org/10.1103/PhysRevX.6.021043
  7. [9]Lawrence Z. Cohen, Isaac H. Kim, Stephen D. Bartlett, and Benjamin J. Brown. 2022. Low-overhead fault-tolerant quantum computing using long-range connectivity. Science Advances 8 (2022), eabn1717. https://doi.org/10.1126/sciadv.abn1717
  8. [10]Alexander Cowtan, Silas Dilkes, Ross Duncan, Will Simmons, and Seon Vijayaragh, 2020. Phase Gadget Synthesis for Shallow Circuits. In Proceedings of the 16th International Conference on Quantum Physics and Logic (QPL 2019) (Electronic Proceedings in Theoretical Computer Science, Vol. 318). https://doi.org/10.4204/EPTCS.318.13
  9. [11]Alexander Cowtan, Zihan Yang, Dominic J. Williamson, and Theodore J. Yoder. 2026. Parallel Logical Measurements via Quantum Code Surgery. PRX Quantum 7 (2026), 020325. https://doi.org/10.1103/gj8x-n5gg
  10. [12]Andrew W. Cross, Zhi yang He, Patrick J. Rall, and Theodore J. Yoder. 2024. Improved QLDPC Surgery: Logical Measurements and Bridging Codes. arXiv:2407.18393 https://arxiv.org/abs/2407.18393v4 Revised October 2025.
  11. [13]Vincent Danos, Elham Kashefi, and Prakash Panangaden. 2007. The measurement calculus. Journal of the ACM (JACM) 54, 2 (2007), 8. https://doi.org/10.1145/1219092.1219096
  12. [14]Ellie D’Hondt and Prakash Panangaden. 2006. Quantum weakest preconditions. Mathematical Structures in Computer Science 16, 3 (2006), 429–451. https://doi.org/10.1017/S0960129506005251
  13. [15]Yuan Feng and Mingsheng Ying. 2021. Quantum Hoare Logic with Classical Variables. ACM Transactions on Quantum Computing 2, 4 (2021), 1–43. https://doi.org/10.1145/3456877
  14. [16]Lov K. Grover. 1996. A Fast Quantum Mechanical Algorithm for Database Search. In Proceedings of the Twenty-Eighth Annual ACM Symposium on Theory of Computing (STOC ’96). Association for Computing Machinery, 212–219. https://doi.org/10.1145/237814.237866
  15. [17]Luke E. Heyfron and Earl T. Campbell. 2018. An efficient quantum compiler that reduces T count. Quantum Science and Technology 4, 1 (2018), 015004. https://doi.org/10.1088/2058-9565/a6d4
  16. [18]Kesha Hietala, Robert Rand, Shih-Han Hung, Liyi Li, and Michael Hicks. 2021a. Proving Quantum Programs Correct. In 12th International Conference on Interactive Theorem Proving (ITP 2021) (Leibniz International Proceedings in Informatics, Vol. 193). Schloss Dagstuhl – Leibniz-Zentrum für Informatik, 21:1–21:19. https://doi.org/10.4230/LIPIcs.ITP.2021.21
  17. [19]Kesha Hietala, Robert Rand, Shih-Han Hung, Xiaodi Wu, and Michael Hicks. 2021b. A Verified Optimizer for Quantum Circuits. Proceedings of the ACM on Programming Languages 5, POPL, Article 37 (2021), 29 pages. https://doi.org/10.1145/3434318
  18. [20]Dominic Horsman, Austin G. Fowler, Simon Devitt, and Rodney Van Meter. 2012. Surface code quantum computing by lattice surgery. New Journal of Physics 14, 12 (2012), 123011. https://doi.org/10.1088/1367-2630/14/12/123011
  19. [21]Shih-Han Hung, Kesha Hietala, Stephen Chong, Shu Mingsheng Ying, Michael Hicks, and Xiaodi Wu. 2019. Quantitative Robustness Analysis of Quantum Programs. Proceedings of the ACM on Programming Languages 3, POPL, Article 31 (2019), 34 pages. https://doi.org/10.1145/3290344
  20. [23]Ang Li, Samuel Stein, Sriram Krishnamoorthy, and James Ang. 2022. QASMBench: A Low-level QASM Benchmark Suite for NISQ Evaluation and Simulation. arXiv:2005.13018 https://arxiv.org/abs/2005.13018v3
  21. [24]Daniel Litinski. 2019. A game of surface codes: Large-scale quantum computing with lattice surgery. Quantum 3 (2019), 128.
  22. [25]Alexandru Paler and Robert Basmajian. 2019. Clifford Gate Optimisation and T Gate Scheduling: Using Queueing Models for Topological Assemblies. In 15th IEEE/ACM International Symposium on Nanoscale Architectures (NANOARCH 2019). IEEE. https://arxiv.org/abs/1906.06400
  23. [26]Jennifer Paykin, Robert Rand, and Steve Zdancewic. 2017. QWIRE: A Core Language for Quantum Circuits. In Proceedings of the 44th ACM SIGPLAN Symposium on Principles of Programming Languages (POPL 2017). ACM, 846–858. https://doi.org/10.1145/3009837.3009894
  24. [27]Neil J. Ross and Peter Selinger. 2016. Optimal ancilla-free Clifford+T approximation of z-rotations. Quantum Information and Computation 16, 11–12 (2016), 901–953. https://arxiv.org/abs/1403.2975
  25. [28]Yunong Shi, Runzhou Tao, Xupeng Li, Ali Javadi-Abhari, Andrew W. Cross, Frederic T. Chong, and Ronghui Gu. 2019. CertiQ: A mostly-automated Verification of a Realistic Quantum Compiler. arXiv:1908.08963 https://arxiv.org/abs/1908.08963
  26. [29]Dominique Unruh. 2019. Quantum Hoare Logic with Ghost Variables. In 34th Annual ACM/IEEE Symposium on Logic in Computer Science (LICS 2019). IEEE, 1–13. https://arxiv.org/abs/1902.00325
  27. [30]Ryo Wakizaka, Yasuharu Suzuki, and Atsushi Igarashi. 2025. Type-Based Verification of Connectivity Constraints in Lattice Surgery. In Programming Languages and Systems (APLAS 2024) (Lecture Notes in Computer Science, Vol. 15194). Springer, Singapore, 216–237. https://doi.org/10.1007/978-981-97-8943-6_11
  28. [31]George Watkins, Hoang Minh Nguyen, Keelan Watkins, Steven Pearce, Hoi-Kwan Lau, and Alexandru Paler. 2024. A High Performance Compiler for Very Large Scale Surface Code Computations. Quantum 8 (2024), 1354. https://doi.org/10.22331/q-2024-05-22-1354
  29. [32]Dominic J. Williamson and Theodore J. Yoder. 2026. Low-overhead fault-tolerant quantum computation by gauging logical operators. Nature Physics 22 (2026), 598–603. https://doi.org/10.1038/s41567-026-03220-8
  30. [33]Huiling Wu, Yuxin Deng, and Ming Xu. 2025. Local Reasoning about Probabilistic Behaviour for Classical–Quantum Programs. arXiv:2308.04741 [cs.PL] https://arxiv.org/abs/2308.04741v3 Extended version, arXiv v3.
  31. [34]Mingsheng Ying. 2009. Hoare Logic for Quantum Programs. arXiv:0906.4586 [quant-ph] https://arxiv.org/abs/0906.4586
  32. [35]John Yuehan Zhang. 2026. CirCLs: Compiling Lattice Surgery to Physical Circuits with Dynamic Allocation. arXiv:2608.23819 https://arxiv.org/abs/2608.23819
  33. [36]Li Zhou, Gilles Barthe, Pierre-Yves Strub, Junyi Liu, and Mingsheng Ying. 2022. CoqQ: Foundational Verification of Quantum Programs. arXiv:2207.11350 [cs.PL] https://arxiv.org/abs/2207.11350
  34. [37]Li Zhou, Nengkun Yu, and Mingsheng Ying. 2019. An applied quantum Hoare logic. In Proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2019). ACM. https://doi.org/10.1145/3314221.3314584

Paper details

vlnc:W_gutzyaeg
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 4

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Physics and Astronomy

Codex

View statement
Looking for related papers…
Contents