TL;DR
Quantum applications are complex pipelines mixing classical preprocessing with quantum execution, but existing workflow tools treat them as static, isolated blocks. This paper introduces LLQM (Low-Level Quantum Machine), a meta-framework that continuously profiles these pipelines alongside real-time hardware noise drift. By dynamically adjusting qubit mapping and error mitigation strategies, LLQM avoids catastrophic fidelity drops and optimizes classical-quantum resource trade-offs.
What Problem Does This Paper Address?
Running a quantum application on today's Noisy Intermediate-Scale Quantum (NISQ) or utility-scale hardware isn't just about sending a circuit to a Quantum Processing Unit (QPU). It involves a multi-stage pipeline: circuit generation, transpilation, qubit layout mapping, quantum error mitigation (QEM), and post-processing.
The core issue is that QPU error rates are highly volatile, drifting on timescales of minutes. A qubit layout or QEM strategy chosen based on yesterday's calibration data can quickly become stale and ruin a calculation. Furthermore, different QEM techniques have vastly different classical compute and memory footprints. Existing workflow managers treat these stages statically and in isolation, leading to massive resource waste (e.g., classical CPUs idling in polling loops) or severe fidelity degradation because they fail to see how classical choices and quantum hardware states interact.
Methods
The authors present LLQM, a profiling-driven meta-framework that shifts quantum pipeline optimization from a static recipe to a dynamic, closed-loop system. Key components include:
- Fine-Grained Task Decomposition: Compiles a quantum job into a directed acyclic graph (DAG) of independent, typed tasks (CPU, GPU, or QPU).
- Continuous Closed-Loop Profiling: Tracks resource usage (IPC, memory bandwidth, QPU time) against real-time QPU calibration snapshots. It features an intra-job loop (to re-evaluate decisions if fidelity targets aren't met) and an inter-job loop (to update cost models for future jobs).
- Hardware-Aware Layout Selection: Uses metrics like Expected Success Probability (ESP) and Circuit-Weighted Average (CWA) error to dynamically score and select optimal physical qubit mappings.
- Dynamic QEM Selection: Formulates an optimization problem to choose the cheapest QEM configuration (e.g., Zero-Noise Extrapolation (ZNE), Probabilistic Error Cancellation (PEC), or Measurement Error Mitigation (REM)) that satisfies the user's target fidelity and resource budgets.
Datasets
The framework was evaluated using benchmark programs from QASMBench, spanning small, medium, and large categories. Workloads included:
- Variational Quantum Eigensolvers (VQE)
- Unitary Coupled Cluster VQE (UCCSD-VQE)
- Transverse-Field Ising Models (Ising)
- Trotter-based dynamics
Circuits scaled up to 100 qubits and $10^7$ transpiled gates, executed on real IBM 156-qubit Heron r2 processors. Mirror circuits were utilized to evaluate execution fidelity without requiring classically intractable state-vector simulations.
Key Insights and Ideas
- Fidelity is a constraint, not a currency: Unlike classical computing where you can trade time for memory, a quantum result below a minimum fidelity threshold is completely useless. If fidelity falls below the target, all spent QPU time is wasted.
- QEM choice causes massive, non-uniform fidelity swings: Applying QEM blindly does not guarantee better results. For instance, PEC can actually degrade fidelity below the unmitigated baseline on larger workloads if misconfigured or run on drifting hardware.
- Classical resources are often the true bottleneck: While ZNE is lightweight, PEC requires a classical sampling overhead that scales exponentially with the circuit fault rate, taking 25–290× longer in classical mitigation than the quantum execution itself.
- Transpiled gate count, not qubit count, predicts cost: Sizing jobs by advertised qubit count leads to mis-provisioning by orders of magnitude; transpiled gate count is a much more reliable predictor of both QPU time and fidelity.
Key Results
- Qubit Selection Impacts: Mapping a 4-qubit circuit onto slightly degraded qubits caused ZNE fidelity to collapse from 0.910 to nearly 0. Alternatively, PEC maintained high fidelity (0.891) on bad qubits but inflated QPU execution time by 1.8× (from 278s to 498s) due to increased sampling needs.
- Classical Phase Heterogeneity: Profiling revealed that PEC's representation generation is highly memory-bound (moving up to 1.16 GB/s DRAM read traffic), while its circuit sampling phase is compute-bound (54% IPC). Meanwhile, classical hosts spent up to 92% of wall-clock time idling in polling loops waiting for QPU results.
- Fidelity Improvements: When properly configured via LLQM, ZNE delivered consistent fidelity improvements (+0.10 to +0.55) across various QASMBench workloads.
Limitations and Future Work
- Predicting Fidelity ($\hat{F}$): Accurately predicting the exact fidelity a QEM configuration will yield remains an open empirical challenge. LLQM currently collects data to build these models but doesn't inherently solve the prediction problem.
- Cold-Start Problem: The profiler relies on historical task records to calibrate cost models, meaning it starts "cold" on new deployments or unprofiled hardware backends.
- Composition of QEM Techniques: LLQM currently selects a single QEM technique at a time; modeling and profiling layered/composed mitigation techniques (which exponentially increases the search space) is left for future work.
- Autonomous Operation: The ultimate goal is to move configuration entirely out of the user's hands, automatically inferring layouts and mitigation strategies purely from the circuit and its constraints.
Summary updated