Hybrid quantum-classical compilers exchange programs among circuit, control-flow, pulse, device, and physical representations. Existing formats make different abstraction choices, so the properties that must survive a lowering step are often enforced by tool-specific code rather than stated in a common intermediate representation (IR). We present QaiJi IR, an eight-layer family organized by a \emph{five-axis semantic contract} for data, semantics, lowering, runtime, and verification. Its L4 SemanticIR records the operation class, declared equivalence level, optimization role, and classical-feedback model as attributes, and maps operation classes to ISA-neutral hardware actions.
The prototype provides typed quantum and classical circuit nodes, OpenQASM~2 compatibility input, canonical OpenQASM~3 output, explicit rejection of unsupported constructs, and executable gate-convention checks. A representative measurement-conditioned program reaches a canonical QASM fixed point, acquires a measurement-to-condition edge, passes an exact aggregate consistency check, and produces a symbolic pulse template. For a one-bit active-reset case, device lowering materializes ALU/FPROC records and a conditional branch. Running the resulting virtual pulse processing unit (VPPU) program with externally supplied outcomes 0 and 1 respectively skips and executes the conditional drive. These tests validate the represented compiler path and binary branch behavior. They do not establish a physical feedback loop, because the simulator cannot yet apply mid-circuit measurement collapse and continue the same dynamical trajectory.
Comments
Submitted manuscript, comments and suggestions are welcome
Hybrid quantum-classical compilers exchange programs among circuit, control-flow, pulse, device, and physical representations. Existing formats make different abstraction choices, so the properties that must survive a lowering step are often enforced by tool-specific code rather than stated in a common intermediate representation (IR). We present QaiJi IR, an eight-layer family organized by a \emph{five-axis semantic contract} for data, semantics, lowering, runtime, and verification. Its L4 SemanticIR records the operation class, declared equivalence level, optimization role, and classical-feedback model as attributes, and maps operation classes to ISA-neutral hardware actions.
The prototype provides typed quantum and classical circuit nodes, OpenQASM2 compatibility input, canonical OpenQASM3 output, explicit rejection of unsupported constructs, and executable gate-convention checks. A representative measurement-conditioned program reaches a canonical QASM fixed point, acquires a measurement-to-condition edge, passes an exact aggregate consistency check, and produces a symbolic pulse template. For a one-bit active-reset case, device lowering materializes ALU/FPROC records and a conditional branch. Running the resulting virtual pulse processing unit (VPPU) program with externally supplied outcomes 0 and 1 respectively skips and executes the conditional drive. These tests validate the represented compiler path and binary branch behavior. They do not establish a physical feedback loop, because the simulator cannot yet apply mid-circuit measurement collapse and continue the same dynamical trajectory.
Compiling quantum programs for fault-tolerant execution requires transforming high-level operations through multiple abstraction layers: from logical gates to error-corrected encodings to hardware-native instructions. A key challenge is that quantum error correction turns purely quantum programs into hybrid quantum-classical programs, where classical feedback from syndrome measurements drives quantum corrections at runtime. Existing compilation frameworks handle these quantum and classical components separately, requiring manual adaptation of classical logic at each compilation stage, all while preserving program semantics. We present qstack, a compiler framework built around a purely quantum intermediate representation in which classical logic is accessed only through opaque callbacks, written in any classical language. The framework's central mechanism, callback wrapping, enables compositional compilation: each compiler pass automatically adapts both quantum operations and their associated classical callbacks, and any kernel dynamically generated by a callback is compiled through the full pipeline. This allows ISA translation and quantum error correction to be expressed as composable compiler passes, including concatenation of error-correcting codes, without manual intervention. We demonstrate end-to-end compilation from a high-level gate set through Clifford gates to trapped-ion native operations, with bit-flip and phase-flip repetition codes, the Steane code, and the Shor code obtained by composing two repetition passes.
Quantum compilers typically follow the circuit model, representing programs as fixed sequences of gates. This static view breaks down in hybrid quantum-classical applications, where gate choices depend on runtime data or measurement results. We introduce a new Intermediate Representation (IR) that elevates gates to first-class values, enabling their dynamic creation, composition, and control. This unified representation allows classical computation to steer quantum behaviour, capturing phenomena including stochastic gate selection, adaptive error correction, and measurement-driven computation within a single framework. Case studies in noise modelling, randomised compilation, error correction, and measurement-based quantum computing show that our IR expresses these programs compactly and supports optimisations that were not possible in the circuit model. Evaluation on a benchmark suite of hybrid quantum-classical programs indicates that our IR represents programs compactly and facilitates compiler analysis and transformation.
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.
Connecting AI-generated quantum programs to executable experiments requires more than syntactically valid code: the workflow must also control execution authority and preserve the basis for interpreting its results. This paper develops a conceptual architecture organized around three responsibilities: AI-assisted circuit proposal, deterministic classical validation, and quantum measurement execution. A quantum-job contract binds circuit artifacts, measurement settings, resource allocations, backend information, and provenance to explicit admission conditions. The design separates permission to run an experiment from evidence that its output answers the intended scientific question. An analytical single-qubit variational example demonstrates this distinction through exact energy calculations, finite-shot variance, and budget-constrained measurement allocation. Responsibility allocation, runtime interception, and staged transformation provide the architectural principles, while uncertainty reporting and reference calculations supply the scientific checks. A prospective evaluation protocol covers accuracy, policy violations, reproducibility, end-to-end cost, and researcher effort. The framework is presented as a design proposal supported by mathematical illustration, not as a tested implementation; its operational benefits and applicability to larger quantum workloads remain to be established.
Emerging quantum applications such as error mitigation, system characterization, and hybrid protocols often require running large families of related quantum circuits. Existing intermediate representations (IRs) and frameworks such as Qiskit, QIR, MitiQ, and OpenQASM do not provide primitives to concisely express such workloads. These tools instead rely on explicit enumeration of the unique circuits within each workload. We introduce Ensemble-IR, an intermediate representation designed to concisely express these ensemble workloads. Rather than enumerating each circuit separately, Ensemble-IR encodes an entire workload through a rich, shared unified program. This program specifies common circuit structure along with symbolic operations to express points of variation - such as gate types, gate placement, parameter values, or qubit configurations. Ensemble-IR enables quantum systems to load an entire family of circuits onto a device as a single concise file, allowing contained circuits to instead be recreated on-the-fly at runtime. We demonstrate Ensemble-IR across 18 real-world workloads from prior literature, highlighting its widespread utility for scalable quantum system development.
Quantum computing frameworks---Qiskit, Cirq, PennyLane, QPanda, and others---each provide their own circuit representations, compilation pipelines, and execution APIs. While individually capable, they are peers: code written for one cannot run on another without manual translation, and optimizations developed for one platform cannot benefit the rest. What is missing is not another framework, but a middleware layer that unifies them. We present QuoNic, a backend-agnostic quantum middleware that treats existing frameworks as compilation targets rather than competitors. QuoNic introduces three key innovations: (1) a vendor-neutral Intermediate Representation (IR) supporting high-level gate semantics that compile down to any backend's native instructions; (2) an intelligent scheduler that automatically selects the optimal backend and simulation method based on circuit features, achieving 1.30x median overhead relative to the best backend across 694 benchmark circuits; and (3) groverize(), a dynamic-to-static compilation pass that transforms repeat-until-success loops into coherent Grover circuits executable on any backend. Evaluated across 12 experiments covering cross-platform consistency, compilation optimization, and real-hardware validation on three quantum platforms, QuoNic achieves sub-millisecond compilation, consistent results across 8 backend configurations, and scales to 40 qubits for Clifford circuits.