Compositional Quantum Control Flow with Efficient Compilation in Qunity

TL;DR

This work advances practical compilation for compositional quantum control flow in Qunity by introducing pmatch and match, two pattern‑matching constructs that extend ctrl while preserving realizability. It delivers the first working Qunity compiler that translates high‑level Qunity programs into OpenQASM 3, augmented with comprehensive low‑ and high‑level optimizations, including direct‑sum restructuring, qubit recycling, and a suite of post‑processing passes. The compiler is evaluated against unoptimized baselines and hand‑crafted Qiskit circuits, showing orders‑of‑magnitude improvements in circuit size and, for many benchmarks, parity with manual implementations. By revising the formalism to ensure encoding validity and developing an IR‑driven pipeline, the work demonstrates that high‑level quantum languages with rich control flow can be practically realized and tuned for hardware‑aware performance. It also outlines a path toward adopting alternative IRs (e.g., QIR/MLIR) to leverage broader optimizers while preserving Qunity’s semantics and typing discipline.

Abstract

Most existing quantum programming languages are based on the quantum circuit model of computation, as higher-level abstractions are particularly challenging to implement - especially ones relating to quantum control flow. The Qunity language, proposed by Voichick et al., offered such an abstraction in the form of a quantum control construct, with great care taken to ensure that the resulting language is still realizable. However, Qunity lacked a working implementation, and the originally proposed compilation procedure was very inefficient, with even simple quantum algorithms compiling to unreasonably large circuits. In this work, we focus on the efficient compilation of high-level quantum control flow constructs, using Qunity as our starting point. We introduce a wider range of abstractions on top of Qunity's core language that offer compelling trade-offs compared to its existing control construct. We create a complete implementation of a Qunity compiler, which converts high-level Qunity code into the quantum assembly language OpenQASM 3. We develop optimization techniques for multiple stages of the Qunity compilation procedure, including both low-level circuit optimizations as well as methods that consider the high-level structure of a Qunity program, greatly reducing the number of qubits and gates used by the compiler.

Figures (14)

• Figure 1: Diagram showing the procedures used in the Qunity interpreter (left path), and the Qunity compiler (right path). Solid and dashed arrows indicate polynomial and exponential time processes respectively.
• Figure 2: (a) The typing judgment T-PurePair for typing pairs of Qunity expressions with a product type. (b) The compilation circuit for T-PurePair as presented in \ref{['app:typing_judgment_compilation']}. (c) Excerpt from the compile_pure_expr_to_inter_op function in the Qunity compiler, written in OCaml. This shows the compilation of the T-PurePair typing judgment into the intermediate representation, corresponding to the circuit in (b).
• Figure 3: An example of the conditional commutation tree transformation, which swaps the two vertices shown in this diagram. Their paths must be identical except for the very first step from the root.
• Figure 4: (a) The circuit produced by compiling a Qunity program for preparing the state $\frac{1}{\sqrt{2}}(\ket{00} + \ket{11})$ without compiler optimizations. (b) The circuit produced using the the optimized compiler for the same program.
• Figure 5: Qunity types.

Theorems & Definitions (4)

• definition 1
• definition 2
• definition 3
• definition 4: Tree derived from the orthogonality judgment