In the classical world, compiling software is a well-solved problem: high-level code is translated into intermediate representations, optimized globally, and mapped directly to machine instructions. In the quantum world, however, compilation remains a major bottleneck.
Traditional quantum compilers treat logical circuits and physical hardware as entirely separate layers. They take an abstract algorithm, decompose it into a standard discrete gate set (such as CNOT, H, and T gates), and then insert auxiliary "SWAP" gates to satisfy the rigid connectivity constraints of a physical chip. As Tobias J. Osborne et al. observe in Optimization Driven Quantum Circuit Reduction, these standard heuristic pipelines frequently leave significant localized redundancies. This early decomposition strips away semantic context, resulting in bloated circuits that suffer heavily from decoherence on Noisy Intermediate-Scale Quantum (NISQ) devices.
To overcome this "scaling wall," a new paradigm has emerged. Instead of optimizing isolated gates within a rigid, pre-defined framework, modern compilers leverage transition-based optimization, physical-logical co-optimization, and hardware-native continuous synthesis. By focusing on how quantum states and operations transition into one another globally, these techniques drastically compress circuit depth and gate counts.
Shifting from Isolated Gates to Transition-Based Optimization
The core intuition behind transition-based optimization is simple: it is often mathematically cheaper to change one operation into another than to build both from scratch.
Traditional compilers optimize each unitary operation in isolation. In contrast, transition-based optimization minimizes the cost of switching between structurally similar operations. In Controlled gate networks: theory and application to eigenvalue estimation, Jacob Watkins demonstrates that when multiple unitary operations share underlying structural similarities, they can be decomposed into shared sequences. Rather than executing independent gate sequences for each unitary, the compiler uses light, auxiliary-controlled "transformation gates" to toggle between them. This approach leverages the shared algebraic structure of the operations, achieving up to a fivefold reduction in critical, high-error two-qubit gates.
Traditional: [ Unitary A ] ---> [ Unitary B ] (Two heavy, independent sequences)
Transition: [ Shared Base Sequence ] ---> [ Light Transformation Gate ] ---> (Switches A to B)
Co-Optimizing Physical Transport and Logical Routing
In static architectures, if Qubit A needs to interact with Qubit C but is only adjacent to Qubit B, the compiler must insert a chain of logical SWAP gates to physically move the state across the grid. This routing overhead scales poorly and rapidly degrades circuit fidelity.
However, emerging hardware platforms—such as trapped ions and neutral atoms—allow qubits to be physically moved across the chip during the execution of a program. Transition-based circuit optimization capitalizes on this by unifying physical transport and logical routing into a single co-optimization framework.
For Quantum Charge-Coupled Device (QCCD) architectures, Chenghong Zhu et al. introduce a unified framework in S-SYNC: Shuttle and Swap Co-Optimization in Quantum Charge-Coupled Devices. Instead of treating physical shuttling as a secondary step to satisfy logical swaps, the authors model the hardware as a static graph with space nodes, optimizing physical trajectories and logical gates simultaneously. This co-optimization eliminates redundant movements, reducing thermal heating and significantly boosting execution fidelity.
A similar breakthrough applies to neutral atom processors utilizing mobile optical tweezers. Jason Ludmir et al. demonstrate in Parallax: A Compiler for Neutral Atom Quantum Computers under Hardware Constraints that replacing logical SWAP gates entirely with physical atom movements yields "zero-SWAP" execution. By moving the atoms themselves into interaction range, the compiler cuts down high-error two-qubit operations. As a result, Daniel Bochen Tan et al. show in Compiling Quantum Circuits for Dynamically Field-Programmable Neutral Atoms Array Processors that leveraging this dynamic reconfigurability can reduce the total two-qubit gate count by more than fivefold compared to static architectures.
Even on fixed-grid architectures where physical movement is impossible, routing can be optimized by looking at path intersections globally. Naoyuki Kamiyama et al. demonstrate in Algorithmic Theory of Qubit Routing that for circuits with disjoint operations, compilers can identify "crossings" where the routing paths of two distinct qubit pairs intersect. By executing a single, well-placed swap at this crossing, the compiler moves both pairs closer to their respective targets simultaneously, rather than routing them independently.
Bypassing Standard Gate Sets via Native and Continuous Synthesis
A major source of circuit bloat is the insistence on translating an algorithm into a rigid, discrete gate set (like CNOT) simply because it is universally understood. If the underlying hardware natively speaks a different algebraic language, this translation introduces massive overhead.
For example, many solid-state quantum computers naturally utilize Heisenberg exchange interactions. Heng Fan et al. proved in Optimal two-qubit quantum circuits using exchange interactions that any universal two-qubit operation can be constructed using exactly three $(SWAP)^\alpha$ gates and six single-qubit rotations. Bypassing standard intermediate gate sets entirely and decomposing unitaries directly into these native interactions achieves the absolute theoretical minimum number of physical operations.
Similarly, rather than restricting synthesis to a discrete gate set, compilers can exploit a continuous range of native two-qubit operations. Brooks Foxen et al. demonstrate this in Demonstrating a Continuous Set of Two-qubit Gates for Near-term Quantum Algorithms by implementing a continuous Fermionic simulation (fSim) gate set directly on superconducting hardware. By tuning the hardware to the exact interaction angles required by the algorithm, the authors achieve a threefold reduction in circuit depth compared to standard CNOT-based compilation.
Discrete Compilation: [Algorithm] ---> [CNOTs] ---> [Hardware Pulses] (Bloated)
Continuous Synthesis: [Algorithm] ---> [Exact fSim Angles] ---> [Hardware Pulses] (Compact)
When compiling to alternative native primitives like the square root of iSWAP (SQiSW), the strategy must adapt. Jiajia Zhang et al. show in Quantum circuit synthesis with SQiSW that managing and optimizing the placement of diagonal gates during the recursive decomposition steps yields significantly tighter gate-count upper bounds than a naive gate-replacement strategy.
Ultimately, this hardware-native approach can be pushed all the way down to the pulse level. Zhirui Hu et al. demonstrate in Toward Consistent High-Fidelity Quantum Learning on Unstable Devices via Efficient In-Situ Calibration that replacing fixed entangling gates with parameterized cross-resonance gates allows specific rotations to be executed directly via calibrated microwave pulses. This minimizes the physical duration of the circuit, protecting the qubits from environmental decoherence.
Global Representations and Scope Control
Local rewrite rules (e.g., replacing two adjacent Hadamard gates with an identity) are fast but inherently short-sighted; they miss large-scale semantic redundancies. To capture these, modern optimizers utilize global intermediate representations.
In PHOENIX: Pauli-Based High-Level Optimization Engine for Instruction Execution on NISQ Devices, Zhaohui Yang et al. demonstrate that optimizing quantum circuits at the global level of Pauli strings—rather than local gate patterns—can reduce gate counts and circuit depth by over 80%. This global view prevents the compiler from locking in redundant operations during early high-level decomposition.
Similarly, global algebraic structures can guide deterministic synthesis. Maximilian Balthasar Mansky et al. show in Near-optimal quantum circuit construction via Cartan decomposition that grouping proportional algebraic generators within a Lie algebra minimizes the total number of required two-qubit gates. The authors note, however, that these deterministic global decompositions produce raw sequences that still require secondary post-processing steps, such as peephole optimization or gate merging, to achieve maximum efficiency.
Global optimization also extends to high-level program control flow. In fault-tolerant quantum computing, conditional statements (like quantum if statements) introduce a massive explosion in expensive multi-controlled T gates. To mitigate this, Charles Yuan et al. introduce a technique called conditional scope narrowing in The T-Complexity Costs of Error Correction for Control Flow in Quantum Computation. This mechanism identifies operations within a conditional block that do not strictly require conditional execution and moves them outside the block. By utilizing uncomputation to manage auxiliary qubits, this approach trades a small, constant overhead for a massive reduction in the overall multi-controlled gate count.
Search-Driven Superoptimization
Because finding the mathematically optimal gate sequence for an arbitrary unitary matrix is an NP-hard problem, researchers are increasingly replacing greedy heuristic compilers with advanced search algorithms and machine learning.
For instance, Xiangzhen Zhou et al. demonstrate in Quantum Circuit Transformation: A Monte Carlo Tree Search Framework that a Monte Carlo Tree Search (MCTS) framework can navigate the massive combinatorial space of circuit transformations far better than traditional compilers, achieving an average reduction in added SWAP gates of over 36% compared to standard baselines.
To balance compilation speed and optimization depth, Amanda Xu et al. propose a stochastic framework called GUOQ in Optimizing Quantum Circuits, Fast and Slow. GUOQ unifies fast, local rewrite rules with slow, deep unitary synthesis. By using simulated annealing to alternate between these two modes, it discovers deep structural compressions that specialized fault-tolerant optimizers miss, reducing two-qubit gate counts without increasing high-cost T-gate counts.
Finally, deep reinforcement learning agents are beginning to rewrite the rules of circuit synthesis entirely. In Quantum circuit optimization with AlphaTensor, Tuomas Laakkonen frames circuit optimization as a symmetric tensor decomposition problem. The agent is incentivized through a reward mechanism to discover specific factor patterns that can be substituted with hardware-efficient "gadgets." These gadgets leverage auxiliary qubits to perform complex operations with a lower effective gate count than human-designed equivalents, routinely breaking past traditional theoretical efficiency limits.
Key Foundational Work
Optimal two-qubit quantum circuits using exchange interactions (2005) — contributed 2 concept elements to this direction.
Fast synthesis of exact minimal reversible circuits using group theory (2005) — contributed 1 concept elements to this direction.
Quantum Formulas: a Lower Bound and Simulation (2001) — contributed 1 concept elements to this direction.