Papers for

quantum compiler developers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

Quantum measurements can be removed from low-space algorithms without error

Unitary RQL Equals RQL

Abstract: Intermediate measurements let quantum computations discard information and reuse their workspace. Deferring all measurements can require storing their entire history, which need not preserve logarithmic space. Fefferman and Remscrim proved that measurements can nevertheless be eliminated with two-sided bounded error, and asked whether the same holds with one-sided error [FR21]. We prove RQLΓ = RQULΓ for the standard gate set Γ = {H, T, CNOT}, preserving polynomial time, logarithmic space, and exactly zero acceptance on no-instances. Our proof extends the density-matrix doubling method of Girish, Raz and Zhan [ GRZ21 ] to general channels, including resets and classical memory. We also prove measurement elimination for broader finite gate sets with exact inverses, including suitable gates with transcendental entries, and establish gate-set independence for a specified family of algebraic gate sets. A separate history-checking construction proves QMAL1,G = QUMAL1,G under explicit gate assumptions: measurements can also be eliminated from logarithmic-space quantum verification while preserving perfect completeness

Mon 5 OctComputational Complexity
The gist
Quantum computers sometimes use measurements during calculations, which can make things tricky to manage with limited memory. The authors show that these measurements can be removed entirely in certain types of quantum algorithms that use very little memory and run efficiently, without losing correctness or making errors on negative cases. Their work extends known methods to more general types of quantum operations and different sets of quantum gates. This helps understand what kinds of quantum computations can be simplified by avoiding intermediate measurements while keeping strong guarantees.
Open → 2610.06231v1

Irene checks equivalence of hybrid quantum programs accurately and fast

Irene: Equivalence Checking of Hybrid Quantum Programs via Structure-Preserving Symbolic Reduction

Abstract: Equivalence checking is essential for validating compiler transformations of hybrid quantum programs, which combine quantum operations, measurements, and classical control. Measurement-dependent control limits unitary reasoning, while dependencies between classical outcomes and quantum operations can enlarge intermediate symbolic states. We present Irene, an equivalence-checking framework for bounded hybrid quantum programs based on structure-preserving symbolic reduction. The framework progressively simplifies equivalence obligations through three levels of reasoning. At the gate level, algebraic identities simplify unitary regions. At the hybrid path-sum (HPS) level, reduced symbolic execution states are represented as typed graphs, whose isomorphism certifies equivalence. Remaining obligations are handled by density kernels that characterize transformations of input density operators into observable outputs, allowing comparison even when internal measurement histories differ. Residual coefficient differences are encoded as SMT queries. A common set of symbolic reductions supports HPS and density-kernel reasoning by preserving factored Boolean and arithmetic expressions, eliminating reducible dependencies before expanding residual sums. We evaluate Irene against five equivalence checkers on 1,982 program pairs from seven benchmark suites. Irene solves 1,584 pairs (79.92%), compared with 57.52% for MQT QCEC, the baseline with the highest aggregate coverage, with a mean end-to-end time of 3.93 seconds per solved pair. Applied as an equivalence-checking oracle, Irene also identifies 15 previously unknown bugs in quantum compilers, including Qiskit, Cirq, and PennyLane.

Mon 28 SeptProgramming LanguagesLogic in Computer ScienceSoftware Engineering
The gist
Checking if two quantum programs do the same thing is hard, especially when they mix quantum and classical parts together. The authors present Irene, a tool that simplifies this process by breaking it down into different stages of reasoning and using symbolic math and graph comparisons. Irene can handle complex cases where measurements and classical controls interact, and it proved better than other tools on many test programs. It even found bugs in popular quantum programming tools, showing its practical usefulness.
Open → 2609.36065v1

Scalability challenges limit fault-tolerant trapped-ion quantum computers

WISER: Systematic Design-Space Exploration of Fault-Tolerant Global Control Trapped-Ions

Abstract: Trapped-ion quantum computers are a leading candidate for scalable fault-tolerant quantum computing, but conventional Quantum Charge-Coupled Device (QCCD) architectures face severe wiring and power constraints as systems scale. The recently proposed WISE promise orders-of-magnitude reductions in wiring complexity but fundamentally alter the hardware--software interface, making it unclear whether such restrictive architectures can feasibly execute quantum error correction (QEC) and eventually support fault-tolerant workloads. We present WISER, a cross-layer architectural design-space exploration framework for globally controlled trapped-ion systems, to determine whether WISE can support early FTQC, and what hardware/compiler/QEC choices are needed. WISER combines novel WISE-specific compilation, noise modelling, and simulation and integrated them into a unified framework. WISER provides comparative lower-bound estimates of logical clock speed and logical error rate, rather than absolute hardware prediction, enabling us to identify viable operating regions while ruling out infeasible ones. To our knowledge, it is the first systematic design space exploration study targeted at WISE and scalable architectures beyond QCCD. Using WISER, we identify a narrow feasible design space requiring two-ion traps, moderate control multiplexing, aggressive recooling, and high-rate bivariate-bicycle codes. Even under $\sim 10\times$ improvements in physical errors, the lower-bound cycle time to achieve $< 10^{-8}$ logical error is $\approx 100\,ms$, which is $3\times$ slower than local control. These results expose a fundamental trade-off between wiring scalability and logical throughput, suggesting that practical early fault-tolerant operation requires complementary $> 10\times$ physical error rate reductions along with substantial $> 100\times$ reduction in fault-tolerant circuit-depth.

Fri 11 SeptHardware Architecture
The gist
Scaling up trapped-ion quantum computers faces major challenges with wiring and power, which can slow down error correction needed for reliable operation. The authors created WISER, a tool to explore how new wiring-reducing designs called WISE affect performance and error rates. They found only a small range of designs that might work well, but even those run noticeably slower than traditional setups. This trade-off means making these systems practical will require big improvements in error rates and circuit efficiency.
Open → 2609.13546v1

QROB benchmarks quantum compilers to reduce overhead on hardware

QROB: Quantifying Realization Overhead in Quantum Compilation via Reverse Construction

Abstract: Quantum compilation reconciles a program's idealized interaction topology with hardware locality constraints, yet evaluations at scale lack calibrated references for realization overhead. We present QROB, a scalable reverse-construction methodology that generates compilation instances backward from directly realizable configurations, retaining the inverse paths as feasible, compiler-independent references. QROB provides a common evaluation substrate for NISQ SWAP routing and fault-tolerant lattice-surgery scheduling, while extending its reference-preserving principle to capacity-constrained quantum memory-access scheduling. Across systems ranging from 9 to 156 qubits, evaluations highlight QROB's utility as both a diagnostic benchmark and a data source. First, for compiler characterization, QROB reveals substantial realization gaps in existing tools, with NISQ compilers incurring up to 24.1x the reference SWAP cost and fault-tolerant compilers requiring up to 7.0x the reference makespan. Second, as a supervision source for data-driven compilation, a router trained on QROB references outperforms Qiskit SABRE on 84.8% of real-world application circuits. Finally, on real hardware, QROB reference realizations achieve a median mirror-circuit survival rate 1.65x that of full Qiskit O3 compilations across three 156-qubit IBM Heron-r2 processors, demonstrating that closing algorithmic compilation gaps translates directly into physical fidelity gains.

Mon 7 SeptHardware Architecture
The gist
Quantum computers need special software called compilers to turn ideal programs into instructions that fit the actual hardware. The authors created QROB, a method that works backwards from hardware-ready setups to measure how hard it is for compilers to realize programs efficiently. They found that many existing compilers cause much more overhead than necessary, and training software with QROB data can improve performance. Testing on real IBM machines showed that better compilation directly improves the accuracy of quantum runs.
Open → 2609.07776v1

Quantum compression changes problem hardness in optimization tasks

Complexity Amplification from Compression in Quantum Random Access Optimization

Abstract: Compressed quantum encodings aim to overcome hardware limitations towards tackling challenging problems at scale, with many classical variables mapped onto noncommuting observables of fewer qubits. Classically, relaxations such as the semidefinite program formulation of MaxCut trade solution quality for computational efficiency. By contrast, quantum relaxations based on compression can amplify the worst-case complexity of the problem being solved. We study quantum random access optimization (QRAO), a special case of the Pauli correlation encoding (PCE) framework that assigns up to three binary variables to the Pauli $X$, $Y$, and $Z$ observables of each qubit, with the packing choices determining the compressed Hamiltonian to be optimized. We identify explicit QRAO optimal energy promise problems complete for NP, StoqMA, and QMA, with inverse-polynomial promise gaps for the latter two. Our problem reductions preserve inverse-polynomial promise gaps without requiring gadgets or ancillas. For any prescribed packing, we show that weighted MaxCut instances compress, up to a known shift and rescaling, to arbitrary nonnegative-weight pairwise Pauli couplings allowed by the packing. For QRAO, using one aligned axis gives an NP-complete energy problem. Using two or three positive aligned Pauli axes generally gives QMA-complete problems, while their bipartite restrictions lie in StoqMA. We show that this computational hardness survives compilation and is practically relevant. Notably, this result applies directly to the current QRAO compiler implementation in Qiskit Optimization 0.7.0, confirming our hardness results are not artifacts of artificial or contrived packing rules. Altogether our results identify worst-case complexity barriers arising from quantum compression, while making no broad claims about typical cases or the performance and trainability of algorithm pipelines that use it.

Mon 7 SeptComputational Complexity
The gist
Solving big optimization problems on quantum computers is hard because qubits are limited. This work shows that using special quantum methods to compress many variables into fewer qubits can actually make some problems even harder in the worst case. The researchers identified categories of problems that become very tough to solve depending on how variables are packed into quantum measurements. Their findings explain fundamental challenges when using quantum compression, especially for current quantum compilers. They do not claim these are typical cases; rather, they highlight the hardest situations possible.
Open → 2609.07090v1