💻 computer science

When Should a Quantum Workflow Call the QPU? - A Systematic Review and Taxonomy of Semantic QPU Minimization

This paper identifies a critical gap in existing quantum workflow systems, which fail to automatically determine if QPU execution is necessary, by analyzing 60 studies to propose a formalized taxonomy and multi-objective optimization framework for "Semantic QPU Minimization" that addresses the disconnect between task scheduling and the fundamental need for quantum hardware.

Original authors: David Vesterlund

Published 2026-10-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: David Vesterlund

Original paper licensed under CC BY 4.0 (https://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

Quantum computers promise to solve problems that would take today's supercomputers thousands of years to crack. They do this by using quantum bits, or qubits, which can exist in many states at once, allowing them to explore vast possibilities simultaneously. However, these machines are currently rare, incredibly expensive, and difficult to access. Researchers who want to use them often face long waiting lines, and every time they run a calculation, they consume a limited budget of "shots," or attempts, before the machine must reset. Because of these constraints, the scientific community has begun to ask a critical question: do we really need to run every single part of a complex calculation on the quantum machine? Could some steps be handled by the powerful classical computers we already have, saving the precious quantum hardware for the tasks where it is truly indispensable?

A new systematic review by David Vesterlund tackles this exact question, examining sixty studies published between 2018 and 2026 that attempt to reduce the burden on quantum hardware. The author calls this effort "semantic quantum minimization," a way of asking whether a planned quantum task actually needs to exist in its current form. The review reveals a significant gap in the field: while researchers have developed dozens of clever tricks to cut down on quantum usage, no existing software system automatically decides whether a specific task should be moved to a classical computer or kept on the quantum one. Instead, current systems simply schedule tasks that have already been defined, asking "where should this run?" rather than "does this need to run on a quantum machine at all?"

The review organizes these sixty studies into a clear map of where and how researchers are trying to save quantum resources. They found that methods operate at four main stages of the scientific process. First, before a quantum circuit is even built, researchers can simplify the problem itself, such as by removing unnecessary connections in a graph or choosing a more efficient way to represent data. Second, during the design of the algorithm, they can prune unnecessary steps or use mathematical shortcuts to reduce the number of gates required. Third, while the machine is running, they can optimize how measurements are taken or group similar tasks together to run them more efficiently. Finally, after a quantum model is trained, they can sometimes replace the quantum component with a classical version that mimics its behavior, saving the quantum hardware for future training only.

Despite the creativity of these methods, the review highlights a troubling lack of real-world testing. The author found that nearly two-thirds of the studies, or 62.1 percent, were tested only in simulations on classical computers, where noise and errors are often ignored. Only a small fraction, about 17 percent, were validated on actual quantum hardware with enough qubits to be considered a large-scale experiment. This means that for most proposed savings, we do not yet know if they hold up when faced with the messy reality of a physical quantum device. Furthermore, the studies rarely report the cost of moving work to classical computers. While they proudly announce how many quantum shots they saved, they almost never mention how much extra time, energy, or processing power their classical computers had to burn to achieve that saving. In fact, zero percent of the papers reported energy consumption, and fewer than 12 percent reported the time their central processors took.

The paper also introduces a framework to measure these trade-offs more honestly. It suggests that saving quantum time is only a win if the cost of running the same task on a classical computer isn't prohibitively high. For example, a method might save ten minutes of quantum time but require five million hours of graphics processing power to do the same job, which would be a net loss. The review shows that while some techniques, like grouping measurements together, offer huge savings with almost no extra cost, others, like trying to simulate a quantum circuit on a classical computer, might require exponential amounts of classical power, making them impractical for large problems.

Perhaps the most significant finding is that the field lacks a unified approach to combining these techniques. Only about 8.6 percent of the studies tried to use more than one method at the same time. Most researchers work in isolation, perfecting one specific trick without seeing how it might interact with others. The author argues that the next major step is not just finding more ways to cut quantum usage, but building a system that can automatically look at a whole workflow, decide which parts can be moved to classical computers, and reorganize the entire process to minimize the load on the quantum machine. Until such a system exists, researchers are left to manually guess which parts of their experiments deserve the scarce and expensive resource of a quantum processor, often without a clear picture of the full cost of their choices.

The review concludes that the question of when to use a quantum computer is not just about the number of qubits available. It is about the nature of the problem and the fidelity required. The author argues that the idea that a problem simply needs a quantum computer once it exceeds a certain size, such as twenty qubits, is a misconception. Classical methods have already proven capable of simulating much larger systems for specific types of calculations. The real challenge is determining when a classical computer can no longer provide the answer with the necessary accuracy, and when the unique properties of a quantum machine become the only viable path forward. By formalizing this decision-making process, the field can move from ad-hoc optimizations to a systematic strategy that ensures quantum resources are used only when they are truly needed.

Technical Summary: When Should a Quantum Workflow Call the QPU?

Problem Statement

Quantum Processing Units (QPUs) are currently scarce, expensive, and subject to significant queue times. While the conventional quantum computing workflow treats the QPU as the primary compute engine for variational algorithms (e.g., VQE, QAOA), a growing body of literature suggests that not all parts of the quantum experimental lifecycle require quantum hardware.

The central problem identified is the lack of a systematic framework to determine whether a planned QPU operation is actually necessary. Existing workflow systems (e.g., QCSC, Qurator, Fluence) focus on scheduling (deciding where a task runs) or backend selection (choosing between simulator and QPU), but none automatically determine if a quantum task should exist at all. Furthermore, the field suffers from a fragmentation of methods, a lack of standardized metrics for resource displacement, and a systematic underreporting of the classical computational costs incurred when offloading work from the QPU.

Methodology

This paper presents a Systematic Mapping Review of 60 studies published between 2018 and 2026. The review follows guidelines for systematic mapping studies (Petersen et al.) and PRISMA 2020 reporting standards.

Search Strategy: Queries were constructed across four concept blocks (quantum resources, reduction terms, classical displacement, workflow terms) using databases (arXiv, IEEE Xplore, ACM, etc.) and publisher platforms.
Snowballing: Due to the lack of a common vocabulary for "QPU minimization" (e.g., papers on warm starts or circuit cutting rarely self-identify as such), the author employed backward and forward snowballing until saturation was reached.
Corpus: The final corpus consists of 60 studies, divided into a Core Corpus (52 papers directly reducing quantum resource vectors) and an Adjacent Systems Corpus (8 papers on scheduling/orchestration).
Data Extraction: A structured schema was used to extract metadata, intervention points, transformation semantics, evidence maturity, and resource displacement data.

Key Contributions

1. Multidimensional Taxonomy

The author introduces a taxonomy with three independent axes to classify QPU minimization methods:

Axis 1: Intervention Points (4 Layers, 12 Points):
- Layer 1 (Problem/Representation): Preprocessing, representation reduction, initialization.
- Layer 2 (Algorithm/Circuit): Parameter optimization, circuit design, decomposition.
- Layer 3 (Execution/Measurement): Execution routing, batching, measurement optimization, shot optimization.
- Layer 4 (Amortization/Hybridization): Quantum/classical division, post-training deployment.
Axis 2: Transformation Semantics (Formalized as DAG Operations):
Methods are categorized by their effect on the workflow Directed Acyclic Graph (DAG):
- Eliminate: Remove the node (e.g., classical-only solver).
- Replace: Substitute with a classical operation (e.g., surrogate, tensor network).
- Compress: Reduce resource requirements (e.g., sparsification, adaptive shots).
- Reuse/Amortize: Cache or transfer results (e.g., parameter transfer).
- Defer: Delay execution (e.g., candidate filtering).
- Batch: Merge operations (e.g., register packing).
Axis 3: Evidence Dimensions:
- Semantic Guarantee (G): Ranging from Exact to Heuristic.
- Evidence Maturity (E): Ranging from Theory (E0) to Production Deployment (E5).
- Hardware Scale (S) & Deployment Maturity (D).

2. Formalization of Semantic QPU Minimization

The paper defines Semantic QPU Minimization as a multi-objective Pareto optimization problem. The goal is to find a set of workflow transformations $T$ that minimizes a quantum resource vector $R_Q$ and classical displacement cost $C_C$ , subject to:

Utility constraints ( $U(T(W)) \ge U(W) - \epsilon$ )
Classical resource budgets ( $C_C \le B_C$ )
Wall-time budgets ( $T_{wall} \le B_T$ )

This formalism distinguishes between scheduling (where to run) and semantic minimization (whether to run).

3. Resource Displacement Framework

The author proposes a framework using three signed quantities to evaluate trade-offs:

$S_Q$ : Quantum savings (positive = saved).
$C_C$ : Classical displacement cost (positive = extra cost).
$L_U$ : Utility loss (positive = degradation).
This framework highlights that reducing QPU usage is not inherently beneficial if it incurs prohibitive classical costs (e.g., massive GPU time).

Key Results

1. Evidence Maturity and Validation

Simulation Dominance: 62.1% of method papers operate at simulation levels only (E1–E2).
Hardware Validation: Only 17.2% of papers reach hardware evidence level E4+ (large hardware experiments $\ge$ 20 qubits).
Semantic Guarantees: G-Exact methods are predominantly found at simulation levels (E1). Hardware-validated methods (E4+) are predominantly G-Approximate or G-Heuristic.

2. Transformation Effectiveness

Replace and Compress: These transformation types yield the largest reported reductions in individual QPU resource dimensions.
- Surrogates achieve orders-of-magnitude reduction.
- Measurement grouping achieves up to 100× reduction.
Composition: Only 8.6% of papers combine multiple techniques. Rigorous evidence on synergistic or additive interaction effects is almost absent.

3. Systemic Gaps in Reporting

Classical Resource Underreporting: There is a critical lack of data on the classical costs of offloading.
- 0% of papers report energy consumption.
- 5.8% report GPU time.
- 11.5% report CPU time.
- Only 15.4% report QPU wall time.
Workflow Systems: An analysis of existing systems (QCSC, Qurator, Fluence, CONQURE, QFaaS, Q-IRIS, Catalyst, CUDA-Q) reveals that none perform automatic semantic QPU minimization. They schedule or compile but do not transform workflows to eliminate or replace planned QPU operations based on utility constraints.

4. Research Gaps

The review identifies 10 specific gaps, including:

Lack of standardized resource-displacement metrics.
Absence of semantic QPU-necessity analysis.
Insufficient quality-preservation tests (lack of standardized $\epsilon$ tolerance).
Conflation of simulator savings with hardware speedups.
No unified framework for QPU avoidance.

Significance and Claims

The paper claims that the field has reached a point where the question is no longer just "how to improve quantum algorithms," but "which parts of the lifecycle can be moved away from the QPU."

The primary significance of this work is the identification of a fundamental gap: while many techniques exist to reduce QPU consumption in isolation, there is no system that automatically determines the necessity of a QPU call for a specific task within an end-to-end workflow. The author argues that "classical simulability is not a qubit cutoff" and that many current workflows can be reorganized around classical/HPC computation before invoking scarce QPU resources.

The paper concludes that Semantic QPU Minimization represents a distinct layer of optimization that must precede scheduling. It calls for the development of software systems that implement the pipeline: Survey $\to$ Formalism $\to$ Empirical Validation $\to$ Software System, to operationalize the trade-off between quantum savings and classical displacement costs.