Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:2610.10427

Design-Time Conformance Checking for Pulse-Level Quantum Control

Rylan Malarchick

quant-phcs.SESubmitted Oct 7, 2026• Announced Oct 8, 2026• 0 citations
arXivHTMLPDF

Abstract

A pulse-level quantum control program is written against a device whose limits are recorded, if at all, in vendor documentation and source code. A program that exceeds them can be refused at compile time. It can also be accepted and silently altered, or compile and then fail at the board. In the last two cases the experiment runs, and the data does not correspond to the program that was written. We present qconform, a checker that decides whether a pulse program is realizable on a device, given a versioned capability descriptor for that device. Every constraint in a descriptor cites the toolchain observation that established it. The checker is design-time, offline, and deterministic, and it uses no floating point. It reports a verdict, the rules it applied, and a coverage manifest that names what it did not check. We evaluate qconform by differential testing against the QICK and Qblox toolchains, on three QICK board configurations and one Qblox cluster. Over 1263 program runs of 969 distinct programs, the checker accepted no program that a toolchain refuses. On both vendors, a descriptor pinned to one toolchain release accepts programs that older releases refuse. The evaluation also found ten defects in the checker and its descriptors, all fixed.

AI Summary

Pulse-level control compilers can silently quantize, alias, or otherwise modify requested operations. This paper asks whether an offline checker can identify device-incompatible programs and predict such modifications before compilation or execution. It introduces **qconform**, a dependency-free C99 checker operating on JSON programs and version-pinned device capability descriptors. Constraints cite supporting toolchain probes; arithmetic uses exact rationals rather than floating point. Reports distinguish pass, failure, and pass with repairs, and include a coverage manifest identifying unchecked constraints. Descriptors cover timing grids, frequency and amplitude limits, memory budgets, and operation-spacing rules. Differential testing against hardware-free QICK and Qblox compilation covers three QICK configurations and one Qblox cluster: **1,263 runs of 969 distinct programs**. Boundary tests and randomized compositions produce no checker acceptance that the pinned toolchain rejects, and no missed or over-predicted observable repairs after fixes. Testing and fault injection found ten checker or descriptor defects, subsequently fixed. Repeating tests with older releases produces false acceptances, demonstrating that compatibility depends on the version pin. The stated claim concerns compilation acceptance, not faithful hardware execution, and finite testing does not prove soundness. Programs have no branches or loops. Additional limitations include an incomplete accumulated-time bound for muxed QICK generators, unsupported or untestable cases, and descriptor-only enforcement of some hardware limits. Forty evaluation rows are excluded as harness limitations. Other vendors and hardware execution are not evaluated; a QICK exporter is the only existing input-language integration.

No sign of AI-generated textAI use disclosedIncremental
AI-assisted tools (Claude, Anthropic) were used for code development, running the differential evaluation, and manuscript preparation.

Central claim may not hold: The abstract describes device realizability, whereas the supported result is scoped conformance to a pinned compiler plus selected hardware constraints, with run-time behavior excluded. Of the reported 1263 runs, 40 are excluded as harness cases, leaving 1223 runs contributing to the soundness comparison. The unqualified statement that a pass implies compilation requires the Section V exception for accumulated timing on muxed QICK generators, whose toolchain constraint the implemented per-pulse check does not establish.

Written by gpt-6.1-sol from the paper's full text. Automated: it can be wrong.

Comments
6 pages, 1 figure, 3 tables. Code: https://github.com/rylanmalarchick/qconform (release v0.1.0)

Related papers

QProgram: A Hardware-Agnostic DSL for Portable Pulse-Level Quantum Programming

Vyron Vasileiadis, Flavie Le Bars, David Arcos

Every quantum operation is ultimately a timed analog control signal, yet pulse-level experiment code usually tangles the science of an experiment together with one vendor’s software stack and one qubit’s wiring. The protocol, the sweeps, and the calibration all end up bound to the machine they were written on, so moving to new hardware often means rewriting the experiment from scratch. QProgram keeps these two concerns apart. You describe what should happen, and the platform decides how to run it on real instruments. A platform is any quantum control system that speaks one small, standard interface. An experiment written this way becomes a portable, inspectable program object rather than a throwaway script. It saves to a round-trip-safe .qp text file, moves to another chip without a rewrite, and is checked against each platform’s capabilities with an explicit host-side and real-time execution plan before anything runs, while new vendor operations can be added without touching the core.

•Jul 20, 2026•0 citations

Measuring Control-Plane Openness in Near-Term Quantum Computing: A Rubric, Its Validation, and an Application to Thirteen Vendor Stacks

Rylan Malarchick

Public access to pulse-level and control-electronics interfaces in commercial quantum computing has bifurcated. This paper proposes a six-axis rubric for measuring control-plane openness, the layer between gate-level circuit specification and physical control electronics, defined operationally so that the same evidence produces the same grade across vendors. The rubric is validated three ways: a blinded re-grading pass that tests whether the cited evidence and the level definitions alone reproduce the recorded grades, a boundary-case methodology that fixes where each level begins and ends, and a published grading protocol that lets others reproduce and contest any cell. A time-point comparison anchored on the February 2025 removal of pulse-level access from IBM hardware establishes that the rubric measures change rather than describing a snapshot. The rubric is applied to thirteen commercial vendors across superconducting, trapped-ion, neutral-atom, and photonic modalities as of May 1, 2026, and one of the three harms it detects is demonstrated through a reproduction-access audit of five pre-2025 IBM Qiskit Pulse experiments, carried through to a structural port to Rigetti Quil-T. The catalog ships as a machine-readable artifact under CC-BY-4.0 with per-cell source URLs (https://doi.org/10.5281/zenodo.20163276). The readings will go stale; the rubric is the contribution that survives them.

quant-pharXiv:2605.15233•May 15, 2026•1 citation

QASMTrans: An End-to-End QASM Compilation Framework with Pulse Generation for Near-Term Quantum Devices

Aaron Hoyt, Meng Wang, Fei Hua +8 more

QASMTrans is a lightweight, high-performance, C++-based quantum compiler that bridges abstract quantum algorithms to device-level control and is designed for just-in-time (JIT) deployment on QPU testbeds with tightly integrated FPGAs or CPUs. We focus on achieving fast transpilation times on circuits of interest, we find more than 100x faster compilation than Qiskit in some circuits with similar circuit quality, enabling transpilation of large, high-depth circuits in seconds. Unlike existing tools, QASMTrans offers end-to-end device-pulse compilation and direct quantum control integration with QICK, closing the gap between logical circuits and hardware control enabling closed-loop optimization. QASMTrans supports latency-aware Application-tailored Gate Sets (AGS) at the pulse level, identifying high-impact gate sequences on the circuit critical path and synthesizing optimized pulse schedules using pre-defined robust circuit ansatz. Validated through integrated QuTiP pulse-level simulation, this is found to significantly reduce execution latency and can improve final-state fidelity by up to 12% in some tested circuits. QASMTrans further implements device-aware, noise-adaptive transpilation that uses device calibration data for circuit placement on high-quality qubits and can focus on the circuit critical path to reduce transpilation-pass time while maintaining comparable fidelity. Additionally, it introduces circuit space sharing via calibration-aware device partitioning, enabling concurrent execution of multiple circuits or shots on a single QPU. Moreover, QASMTrans is entirely self-contained and has no external library dependencies, making it easy for practical deployment. By combining fast compilation, pulse-level control, and noise-aware optimization, QASMTrans enables real-time adaptive algorithms such as ADAPT-VQE and ADAPT-QAOA.

quant-pharXiv:2602.05154•ACM Transactions on Quantum Computing•Feb 6, 2026•0 citations

QDiff: Differential Testing of Quantum Software Stacks

Jiyuan Wang, Qian Zhang, Guoqing Harry Xu +1 more

Over the past few years, several quantum software stacks (QSS) have been developed in response to rapid hardware advances in quantum computing. A QSS includes a quantum programming language, an optimizing compiler that translates a quantum algorithm written in a high-level language into quantum gate instructions, a quantum simulator that emulates these instructions on a classical device, and a software controller that sends analog signals to a very expensive quantum hardware based on quantum circuits. In comparison to traditional compilers and architecture simulators, QSSes are difficult to tests due to the probabilistic nature of results, the lack of clear hardware specifications, and quantum programming complexity.This work devises a novel differential testing approach for QSSes, named QDiff with three major innovations: (1) We generate input programs to be tested via semantics-preserving, source to source transformation to explore program variants. (2) We speed up differential testing by filtering out quantum circuits that are not worthwhile to execute on quantum hardware by analyzing static characteristics such as a circuit depth, 2-gate operations, gate error rates, and T1 relaxation time. (3) We design an extensible equivalence checking mechanism via distribution comparison functions such as Kolmogorov–Smirnov test and cross entropy.We evaluate QDiff with three widely-used open source QSSes: Qiskit from IBM, Cirq from Google, and Pyquil from Rigetti. By running QDiff on both real hardware and quantum simulators, we found several critical bugs revealing potential instabilities in these platforms. QDiff’s source transformation is effective in producing semantically equivalent yet not-identical circuits (i.e., 34% of trials), and its filtering mechanism can speed up differential testing by 66%.

arXiv:2611.08220•IEEE/ACM International Conference on Automated Software Engineering (ASE)•Nov 1, 2021•83 citations

The QICK (Quantum Instrumentation Control Kit): Readout and control for qubits and detectors

Leandro Stefanazzi, Kenneth Treptow, Neal Wilcer +14 more

We introduce a Xilinx RF System-on-Chip (RFSoC)-based qubit controller (called the Quantum Instrumentation Control Kit, or QICK for short), which supports the direct synthesis of control pulses with carrier frequencies of up to 6 GHz. The QICK can control multiple qubits or other quantum devices. The QICK consists of a digital board hosting an RFSoC field-programmable gate array, custom firmware, and software and an optional companion custom-designed analog front-end board. We characterize the analog performance of the system as well as its digital latency, important for quantum error correction and feedback protocols. We benchmark the controller by performing standard characterizations of a transmon qubit. We achieve an average gate fidelity of Favg=99.93%. All of the schematics, firmware, and software are open-source.

arXiv:2110.00557•Review of Scientific Instruments•Apr 1, 2022•179 citations

Concolic Testing for Quantum Compilers

Navnil Choudhury, Ameya Bhave, Kanad Basu

Quantum circuit transpilation is central to the execution of programs on noisy intermediate-scale quantum (NISQ) devices, yet it introduces reliability risks due to heuristic optimizations, parameter thresholds, and layout heuristics. Small perturbations at these decision points can silently alter program semantics, undermine optimization effectiveness, or increase hardware error susceptibility. In this work, we present a concolic testing framework for quantum compilers that systematically uncovers such vulnerabilities by combining concrete execution with symbolic reasoning. We identify and recover decision points in gate-level, parameter-sensitive, and circuit-level transpiler passes, and construct symbolic guards to drive targeted perturbations near boundary conditions. Our evaluation on representative QASMBench circuits demonstrates complete decision-point and boundary coverage of 100%, and high outcome coverage of 78%, uncovering both missed optimizations and semantic deviations in widely used Qiskit passes. These results establish that concolic testing can be applied as a practical methodology for systematically evaluating compiler robustness in the NISQ era.

IEEE International Conference on Computer Design: VLSI in Computers and Processors (ICCD)•Nov 10, 2025•2 citations
A pulse-level quantum control program is written against a device whose limits are recorded, if at all, in vendor documentation and source code. A program that exceeds them can be refused at compile time. It can also be accepted and silently altered, or compile and then fail at the board. In the last two cases the experiment runs, and the data does not correspond to the program that was written. We present qconform, a checker that decides whether a pulse program is realizable on a device, given a versioned capability descriptor for that device. Every constraint in a descriptor cites the toolchain observation that established it. The checker is design-time, offline, and deterministic, and it uses no floating point. It reports a verdict, the rules it applied, and a coverage manifest that names what it did not check. We evaluate qconform by differential testing against the QICK and Qblox toolchains, on three QICK board configurations and one Qblox cluster. Over 1263 program runs of 969 distinct programs, the checker accepted no program that a toolchain refuses. On both vendors, a descriptor pinned to one toolchain release accepts programs that older releases refuse. The evaluation also found ten defects in the checker and its descriptors, all fixed.
Pulse-level control compilers can silently quantize, alias, or otherwise modify requested operations. This paper asks whether an offline checker can identify device-incompatible programs and predict such modifications before compilation or execution.
It introduces qconform, a dependency-free C99 checker operating on JSON programs and version-pinned device capability descriptors. Constraints cite supporting toolchain probes; arithmetic uses exact rationals rather than floating point. Reports distinguish pass, failure, and pass with repairs, and include a coverage manifest identifying unchecked constraints. Descriptors cover timing grids, frequency and amplitude limits, memory budgets, and operation-spacing rules.
Differential testing against hardware-free QICK and Qblox compilation covers three QICK configurations and one Qblox cluster: 1,263 runs of 969 distinct programs. Boundary tests and randomized compositions produce no checker acceptance that the pinned toolchain rejects, and no missed or over-predicted observable repairs after fixes. Testing and fault injection found ten checker or descriptor defects, subsequently fixed. Repeating tests with older releases produces false acceptances, demonstrating that compatibility depends on the version pin.
The stated claim concerns compilation acceptance, not faithful hardware execution, and finite testing does not prove soundness. Programs have no branches or loops. Additional limitations include an incomplete accumulated-time bound for muxed QICK generators, unsupported or untestable cases, and descriptor-only enforcement of some hardware limits. Forty evaluation rows are excluded as harness limitations. Other vendors and hardware execution are not evaluated; a QICK exporter is the only existing input-language integration.
Every quantum operation is ultimately a timed analog control signal, yet pulse-level experiment code usually tangles the science of an experiment together with one vendor’s software stack and one qubit’s wiring. The protocol, the sweeps, and the calibration all end up bound to the machine they were written on, so moving to new hardware often means rewriting the experiment from scratch. QProgram keeps these two concerns apart. You describe what should happen, and the platform decides how to run it on real instruments. A platform is any quantum control system that speaks one small, standard interface. An experiment written this way becomes a portable, inspectable program object rather than a throwaway script. It saves to a round-trip-safe .qp text file, moves to another chip without a rewrite, and is checked against each platform’s capabilities with an explicit host-side and real-time execution plan before anything runs, while new vendor operations can be added without touching the core.
Public access to pulse-level and control-electronics interfaces in commercial quantum computing has bifurcated. This paper proposes a six-axis rubric for measuring control-plane openness, the layer between gate-level circuit specification and physical control electronics, defined operationally so that the same evidence produces the same grade across vendors. The rubric is validated three ways: a blinded re-grading pass that tests whether the cited evidence and the level definitions alone reproduce the recorded grades, a boundary-case methodology that fixes where each level begins and ends, and a published grading protocol that lets others reproduce and contest any cell. A time-point comparison anchored on the February 2025 removal of pulse-level access from IBM hardware establishes that the rubric measures change rather than describing a snapshot. The rubric is applied to thirteen commercial vendors across superconducting, trapped-ion, neutral-atom, and photonic modalities as of May 1, 2026, and one of the three harms it detects is demonstrated through a reproduction-access audit of five pre-2025 IBM Qiskit Pulse experiments, carried through to a structural port to Rigetti Quil-T. The catalog ships as a machine-readable artifact under CC-BY-4.0 with per-cell source URLs (https://doi.org/10.5281/zenodo.20163276). The readings will go stale; the rubric is the contribution that survives them.
QASMTrans is a lightweight, high-performance, C++-based quantum compiler that bridges abstract quantum algorithms to device-level control and is designed for just-in-time (JIT) deployment on QPU testbeds with tightly integrated FPGAs or CPUs. We focus on achieving fast transpilation times on circuits of interest, we find more than 100x faster compilation than Qiskit in some circuits with similar circuit quality, enabling transpilation of large, high-depth circuits in seconds. Unlike existing tools, QASMTrans offers end-to-end device-pulse compilation and direct quantum control integration with QICK, closing the gap between logical circuits and hardware control enabling closed-loop optimization. QASMTrans supports latency-aware Application-tailored Gate Sets (AGS) at the pulse level, identifying high-impact gate sequences on the circuit critical path and synthesizing optimized pulse schedules using pre-defined robust circuit ansatz. Validated through integrated QuTiP pulse-level simulation, this is found to significantly reduce execution latency and can improve final-state fidelity by up to 12% in some tested circuits. QASMTrans further implements device-aware, noise-adaptive transpilation that uses device calibration data for circuit placement on high-quality qubits and can focus on the circuit critical path to reduce transpilation-pass time while maintaining comparable fidelity. Additionally, it introduces circuit space sharing via calibration-aware device partitioning, enabling concurrent execution of multiple circuits or shots on a single QPU. Moreover, QASMTrans is entirely self-contained and has no external library dependencies, making it easy for practical deployment. By combining fast compilation, pulse-level control, and noise-aware optimization, QASMTrans enables real-time adaptive algorithms such as ADAPT-VQE and ADAPT-QAOA.
Over the past few years, several quantum software stacks (QSS) have been developed in response to rapid hardware advances in quantum computing. A QSS includes a quantum programming language, an optimizing compiler that translates a quantum algorithm written in a high-level language into quantum gate instructions, a quantum simulator that emulates these instructions on a classical device, and a software controller that sends analog signals to a very expensive quantum hardware based on quantum circuits. In comparison to traditional compilers and architecture simulators, QSSes are difficult to tests due to the probabilistic nature of results, the lack of clear hardware specifications, and quantum programming complexity.This work devises a novel differential testing approach for QSSes, named QDiff with three major innovations: (1) We generate input programs to be tested via semantics-preserving, source to source transformation to explore program variants. (2) We speed up differential testing by filtering out quantum circuits that are not worthwhile to execute on quantum hardware by analyzing static characteristics such as a circuit depth, 2-gate operations, gate error rates, and T1 relaxation time. (3) We design an extensible equivalence checking mechanism via distribution comparison functions such as Kolmogorov–Smirnov test and cross entropy.We evaluate QDiff with three widely-used open source QSSes: Qiskit from IBM, Cirq from Google, and Pyquil from Rigetti. By running QDiff on both real hardware and quantum simulators, we found several critical bugs revealing potential instabilities in these platforms. QDiff’s source transformation is effective in producing semantically equivalent yet not-identical circuits (i.e., 34% of trials), and its filtering mechanism can speed up differential testing by 66%.
We introduce a Xilinx RF System-on-Chip (RFSoC)-based qubit controller (called the Quantum Instrumentation Control Kit, or QICK for short), which supports the direct synthesis of control pulses with carrier frequencies of up to 6 GHz. The QICK can control multiple qubits or other quantum devices. The QICK consists of a digital board hosting an RFSoC field-programmable gate array, custom firmware, and software and an optional companion custom-designed analog front-end board. We characterize the analog performance of the system as well as its digital latency, important for quantum error correction and feedback protocols. We benchmark the controller by performing standard characterizations of a transmon qubit. We achieve an average gate fidelity of Favg=99.93%. All of the schematics, firmware, and software are open-source.
Quantum circuit transpilation is central to the execution of programs on noisy intermediate-scale quantum (NISQ) devices, yet it introduces reliability risks due to heuristic optimizations, parameter thresholds, and layout heuristics. Small perturbations at these decision points can silently alter program semantics, undermine optimization effectiveness, or increase hardware error susceptibility. In this work, we present a concolic testing framework for quantum compilers that systematically uncovers such vulnerabilities by combining concrete execution with symbolic reasoning. We identify and recover decision points in gate-level, parameter-sensitive, and circuit-level transpiler passes, and construct symbolic guards to drive targeted perturbations near boundary conditions. Our evaluation on representative QASMBench circuits demonstrates complete decision-point and boundary coverage of 100%, and high outcome coverage of 78%, uncovering both missed optimizations and semantic deviations in widely used Qiskit passes. These results establish that concolic testing can be applied as a practical methodology for systematically evaluating compiler robustness in the NISQ era.