⚛️ quantum physics

A Dynamic Intermediate Representation for Hybrid Quantum-Classical Programs

This paper introduces a novel Intermediate Representation that elevates quantum gates to first-class values, enabling a unified framework for dynamically creating and controlling gates based on runtime data to effectively support hybrid quantum-classical programs and advanced compiler optimizations.

Original authors: Alex Rice, Chris Heunen, Tobias Grosser

Published 2026-09-02

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Alex Rice, Chris Heunen, Tobias Grosser

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

In the emerging field of quantum computing, scientists are trying to harness the strange rules of the subatomic world to solve problems that are impossible for today's machines. The standard way to describe these calculations is through a "circuit," a fixed sequence of steps where tiny particles called qubits pass through a series of gates. Think of this like a train on a set track: once the journey begins, the route is locked in, and the train cannot change direction or speed based on what it sees along the way. This static approach works well for simple, pre-planned tasks. However, the most powerful applications of quantum technology require a different kind of flexibility. Real-world quantum programs often need to make decisions while they run, adjusting their path based on random events or the results of measurements taken during the process. This creates a hybrid system where classical logic and quantum mechanics must talk to each other constantly. The current tools for building these programs struggle to handle this back-and-forth, often forcing developers to break a single, fluid task into many separate, rigid pieces.

A team of researchers from the University of Edinburgh and the University of Cambridge has introduced a new way to build these hybrid programs that treats the steps of the calculation as flexible, living values rather than fixed instructions. Instead of defining a program as a static list of gates that must be written down before the computer starts, their new system allows the gates themselves to be created and chosen while the program is running. In this new framework, a gate is not a permanent brick in a wall; it is a value that can be passed around, combined with other values, and decided upon by classical data just like any other piece of information. This shift allows the computer to steer the quantum behavior dynamically, enabling it to adapt to noise, correct errors on the fly, or change its strategy based on what it has just measured, all within a single, unified description.

The researchers demonstrated the power of this approach by showing how it simplifies complex tasks that are currently difficult to manage. For instance, consider a common problem where a quantum system is subject to random noise, causing a gate to flip a qubit's state with a certain probability. In the old static model, representing this uncertainty required generating a completely new circuit for every possible outcome, leading to a massive explosion of separate programs. With the new dynamic representation, the choice of whether to apply the gate or not is handled as a single, fluid operation that depends on a random number generated at runtime. This keeps the structure of the program clean and compact. The researchers showed that by using this method, they could fuse multiple probabilistic steps into a single, streamlined operation, reducing the complexity of the code significantly.

To make this system practical, the team developed specific tools called "gadgets" that act as building blocks for these dynamic decisions. One such gadget allows the computer to easily combine different types of basic quantum switches, known as Pauli gates, into a single conditional unit. This capability is crucial for advanced techniques like randomised compilation, a method used to smooth out the effects of noise on a quantum computer. In traditional setups, this process involves running the same circuit many times with slightly different random tweaks, then averaging the results. This usually requires generating and optimizing thousands of separate circuits, a slow and inefficient process. The new system allows the compiler to optimize the entire process before any random choices are made, delaying the creation of individual circuits until the very end. When tested, this approach was up to twenty percent faster than current methods for generating large numbers of these randomized circuits, while also using far less memory to store the program description.

The utility of this dynamic representation extends to error correction, a vital requirement for building reliable quantum computers. In these systems, the computer must constantly check for mistakes and apply fixes, but the time it takes to decide on a fix can slow down the entire process. The researchers showed that their new framework allows these corrective steps to be delayed and combined with future steps, effectively buffering the work so that the next round of checking can begin before the previous correction is fully finished. This optimization is essential for modern error correction workflows that aim to perform millions of cycles per second. By treating the correction as a dynamic value that can be moved and merged, the system reduced the number of quantum operations needed by a significant margin, proving that the approach can handle the intense demands of real-world fault-tolerant computing.

Beyond error correction, the new system bridges the gap between two different ways of thinking about quantum computation: the standard circuit model and a newer approach called measurement-based computing, where the calculation is driven entirely by the act of measuring particles. The researchers demonstrated that their framework could translate programs from one style to the other using simple, local changes, without needing complex, global rewrites. This flexibility suggests that the system can serve as a universal language for different quantum paradigms, allowing developers to move between them as needed. When the team compared their new representation against existing industry standards using a suite of diverse hybrid algorithms, their system consistently produced more concise code. It required fewer lines of text, fewer distinct operations, and significantly less complex control flow, making the programs easier to analyze and transform.

The work presented by these researchers does not claim to have solved every problem in quantum computing, but it offers a fundamental shift in how these programs are described and optimized. By elevating gates to the status of dynamic values, the team has created a representation that is better suited for the messy, adaptive reality of hybrid quantum-classical applications. The results indicate that this approach can make the compilation of complex programs faster and more efficient, while also opening the door to new types of optimizations that were previously impossible in a static model. As quantum hardware continues to evolve, the ability to write programs that can think and adapt in real time will likely become just as important as the hardware itself, and this new intermediate representation provides a solid foundation for that future.

Technical Summary: A Dynamic Intermediate Representation for Hybrid Quantum-Classical Programs

Problem Statement

Quantum compilers predominantly rely on the static circuit model, representing programs as fixed sequences of gates. This paradigm is insufficient for hybrid quantum-classical applications where gate selection depends on runtime data, measurement outcomes, or classical control flow. In the static model, phenomena such as stochastic gate selection (e.g., noise channels), adaptive error correction, and measurement-driven computation require generating distinct circuit instances for every random sample or branching path. This approach obscures the quantum dataflow, complicates analysis (such as verifying linear qubit usage), and prevents optimizations that span the boundary between classical and quantum components. Existing toolkits like OpenQASM 3.0 and t|ket⟩2 have begun integrating classical control, but they often rely on explicit control flow structures that fragment the quantum representation, making cross-boundary optimizations difficult.

Methodology

The authors propose a new Intermediate Representation (IR) based on dynamic gates, which elevates quantum gates to first-class runtime values. This representation is implemented as a set of dialects within the MLIR (Multi-Level Intermediate Representation) framework, utilizing Static Single-Assignment (SSA) form with value semantics for qubits.

Core Mechanisms

Dynamic Gate Operations (qssa.dyn_gate): Unlike traditional IRs where a gate is a static operation, this IR treats the gate itself as an operand. A dyn_gate operation takes a gate.value (a runtime value) and applies it to a qubit. This gate value can be generated by classical computation, such as selecting between a $Z$ gate and the Identity gate based on a random variable.
Gate Values and Attributes: Static gates are represented via attributes (e.g., #gate.z), while dynamic gates are constructed using gate.constant or specialized operations. This allows the IR to maintain a unified circuit structure where the quantum dataflow remains linear and explicit, even when the specific gate applied is determined dynamically.
XZ and XZS Gadgets: To facilitate optimization, the authors introduce specialized operations for generating gate values:
- XZ Gadget (gate.xz): Represents a conditional combination of Pauli $X$ and $Z$ gates ( $X^x Z^z$ ) based on boolean operands.
- XZS Gadget (gate.xzs): Extends the XZ gadget to include the Phase gate $S$ ( $X^x Z^z S^s$ ).
- These gadgets allow the IR to represent conditional Pauli operators compactly. The authors define optimization pipelines (xzs-simplify and xz-propagation) that fuse consecutive gadgets, commute them through other gates (Pauli propagation), and simplify conditional logic by pushing selections down to the boolean operands.

Optimization Pipelines

The IR supports specific compiler passes that leverage these gadgets:

Fusion: Consecutive dynamic applications of XZ(S) gadgets are fused into a single gadget by performing arithmetic operations (e.g., XOR) on their boolean parameters.
Propagation: Gadgets can be commuted through Clifford gates (e.g., Hadamard, CX) to the end of the circuit, merging with subsequent corrections. This is crucial for delaying corrective operations in error correction.
Lowering: The IR can be lowered to traditional control flow (e.g., scf.if) or QIR (Quantum Intermediate Representation) by converting dynamic gates back to static selections or branching structures.

Key Contributions

Dynamic Gate Model: A compiler IR that treats gates as runtime values, enabling tight coupling between classical control and quantum execution without fragmenting the quantum dataflow.
XZ/XZS Gadgets: A novel representation for conditional Pauli and Phase gates that enables elegant local rewrites and optimizations across the quantum-classical boundary.
Benchmark Suite: A curated collection of hybrid quantum-classical programs covering diverse paradigms (e.g., NISQ variational algorithms, measurement-based computing, error correction) used to evaluate the IR.

Results and Evaluation

The authors evaluated their IR through case studies and a comparative benchmark against QIR (Quantum Intermediate Representation).

Case Studies

Randomised Compilation: The dynamic gate IR allows padding gates (random Pauli gates) to be represented as dynamic values and fused before random variables are instantiated. This reduces compilation time by up to 20% for large numbers of circuit instantiations compared to the approach of cloning and optimizing each circuit individually. It also significantly reduces representation size, as a single dynamic program can generate arbitrary samples.
Quantum Error Correction (QEC): The xz-propagation pipeline successfully delays corrective operations in QEC cycles. By commuting corrections past subsequent syndrome measurements and fusing them, the IR reduces the number of quantum operations required. Benchmarks on the 5-qubit perfect code showed a reduction in quantum operations (e.g., from 420 to 325 for 10 cycles) with only a minor increase in classical operations.
Measurement-Based Quantum Computing (MBQC): The IR can represent MBQC programs and convert circuit-based programs (using $J(\theta)$ gates) into MBQC measurement patterns via local rewrites. The explicit classical dataflow in the IR eliminates the need for "signal shifting" operations typically required in the measurement calculus to track measurement outcomes.

Benchmarking Suite

The authors compared their Dynamic Gate IR against QIR across 10 hybrid programs. The Dynamic Gate IR demonstrated superior conciseness and reduced complexity:

47% fewer lines and 52% fewer words.
24% fewer quantum operations.
69% fewer basic blocks and 52% less cyclomatic complexity, indicating a significant reduction in unstructured control flow.
30% lower Halstead difficulty, suggesting reduced cognitive complexity.

Significance

The paper claims that the Dynamic Gate IR advances the state of the art by providing a unified framework for hybrid quantum-classical programs. By treating gates as values, the IR bridges the gap between classical and quantum computation, enabling optimizations that were previously impossible or intractable in static circuit models. The authors argue that this representation is not only more compact but also facilitates compiler analysis and transformation, particularly for applications involving adaptive error correction, noise modeling, and measurement-driven computation. The work suggests that adhering to a static circuit model is unnecessary for quantum programs, which are inherently dynamic, and that a dynamic representation is better suited for the evolving landscape of hybrid quantum computing.