Papers for

quantum hardware operators

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.

Symmetry based testing detects issues in quantum algorithm results

Symmetry-Oriented Testing Framework for Variational Quantum Algorithms

Abstract: Testing quantum software is challenging because quantum states cannot be directly inspected. Variational quantum algorithms (VQAs) are a particularly important target as they are among the most promising approaches for near-term noisy quantum hardware. Many testing methods rely on classically computed results, which conflicts with the regime where quantum advantage is expected. Although prior studies mitigate this oracle problem, the core difficulty remains that existing approaches do not verify whether the execution deviates from the intended problem or whether the obtained solution is physically plausible. We propose a symmetry-oriented testing framework for VQAs that addresses this gap by using operators commuting with the target Hamiltonian as test specifications. The framework provides two complementary diagnostics: a commutator-based health check that monitors whether each execution step during optimization remains consistent with the symmetry of the target Hamiltonian, and a variance-based acceptance check that assesses the converged solution by examining whether the state is an eigenstate of the symmetry operators. Both diagnostics derive from the problem structure and do not require the exact solution. We evaluate the framework on representative user- and system-side faults, across multiple target systems, and under injected noise. Results show that the two diagnostics detect faulty behavior, provide informative signals of solution quality, and remain useful under noisy execution.

Wed 21 OctSoftware Engineering
The gist
Testing software for quantum computers is hard because you cannot directly look inside quantum states. The authors introduce a new way to check if quantum algorithms that use special symmetries are working right without needing to know the exact answer. Their method watches whether the steps stay consistent with expected symmetries and checks if the final state fits the problem structure. This helps find errors and tells how good the solution is, even when there is noise in the quantum computer.
Open → 2610.29053v1

Learning to pick quantum angles speeds up combinatorial optimization

Learning angles for quantum approximate optimization

Abstract: The Quantum Approximate Optimization Algorithm (QAOA) and its variants are leading algorithms to help solve challenging combinatorial optimization problems. QAOA maps these problems to Ising Hamiltonians such that their ground state is the desired solution. Candidate solutions are then drawn from a variational quantum circuit. The performance of QAOA hinges on a set of variational angles. However, finding good angles is an instance-specific and computationally expensive non-convex classical optimization task. Here, we learn the mapping from the problem instance to high-quality QAOA angles. Our learned models replace the per-instance optimization, that we call the solver, with a single forward pass that is several orders of magnitude faster than the solver with a near identical quality. Our models further generalize to unseen topologies such as Barabási-Albert and 2D grid graphs. Experiments on quantum hardware confirm that QAOA samples with angles produced by our open-source models are indistinguishable from solver angles. Crucially, models sensitive to the topology of the problem instance increase the quality of the QAOA angles. Our work amortizes a major bottleneck in QAOA by an up-front data generation and training cost. Importantly, this cost can be amortized over time in settings where many similar problems are optimized on a regular basis, as is often the case in applications for industry.

Fri 16 OctMachine Learning
The gist
Some quantum algorithms need specific angles to find good solutions for tough problems, but figuring out these angles is slow and tricky. The authors developed a way to teach a model how to pick these angles quickly by learning from many examples. This means the model can suggest good angles fast for new problems, even ones that look different from what it trained on. They tested the model on real quantum devices and found it works just as well as slower traditional methods.
Open → 2610.23296v1

Predicting noisy quantum circuit simulation runtime after transpilation

Transpilation-Aware Runtime Prediction for Noisy Quantum Circuit Simulation

Abstract: Predicting the runtime of noisy quantum circuit simulations is important for scheduling, resource allocation, and performance optimization. However, accurate prediction is challenging because backend-aware transpilation can substantially alter the original circuit structure, while the backend-derived noise model and simulator execution behavior can introduce additional runtime variation. We study the effectiveness of graph neural networks (GNNs) and conventional regression methods in predicting Qiskit Aer simulation runtime measured after transpilation. We construct a dataset from a benchmark pool of 1,402 unique circuits spanning 22 circuit families, two Qiskit fake-backend configurations, and four transpiler optimization levels. Specifically, we compare a source GNN using original circuit information, hybrid GNN combining source-level graph with post-transpilation features, and transpiled GNN using only transpiled circuit information, along with five regression models. In the overall-model setting, the transpiled GNN achieves the strongest performance among the graph-based representations at all four optimization levels, obtaining $R^2$ values of 0.974, 0.713, 0.745, and 0.605 for optimization levels 0 through 3, respectively. However, under backend-specific evaluation, the advantage of GNN decreases, with conventional regression models matching or outperforming the GNNs in several settings. These results indicate that post-transpilation information is useful, while the value of explicit graph modeling depends on the backend and optimization level.

Fri 11 SeptPerformance
The gist
Figuring out how long it takes to simulate quantum circuits with noise is tricky because the circuits often change after being prepared for a specific quantum computer backend. The authors studied different ways to predict simulation time, comparing graph neural networks that look at circuit structure before and after these changes with traditional regression methods. They found that using information from after the changes (transpilation) helps make better predictions, but traditional methods can sometimes match or beat neural networks depending on the simulation setup. This work helps improve planning and resource use in noisy quantum computing simulations.
Open → 2609.12980v1

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