⚛️ quantum physics

StableShots: Online Shot Stopping for Quantum Circuit Execution

StableShots is a black-box online stopping rule that dynamically determines the optimal number of measurements for static quantum circuits by monitoring distribution stability, thereby outperforming fixed-shot baselines in accuracy and shot efficiency across diverse circuit families and noisy backends.

Original authors: Giuseppe Bisicchia, Alessandro Bocci, Ernesto Pimentel, Antonio Brogi

Published 2026-06-23

📖 3 min read🧠 Deep dive

CC BY 4.0

Original authors: Giuseppe Bisicchia, Alessandro Bocci, Ernesto Pimentel, Antonio Brogi

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

Imagine you are trying to guess the flavor profile of a giant, mysterious soup by taking tiny spoonfuls.

In the world of quantum computing, running a "circuit" (a calculation) is like taking those spoonfuls. Each time you run the circuit, you get one result, or "shot." To understand the full picture of what the computer is doing, you need to take many shots and see how often different results appear.

The Problem: The "Fixed Spoon" Dilemma
Currently, developers have to decide before they start how many spoonfuls to take. They have to pick a fixed number, like "I will take exactly 5,000 spoonfuls."

The Risk: If they pick too few (say, 100), they might miss the rare flavors and get a wrong idea of the soup.
The Waste: If they pick too many (say, 100,000), they are wasting time and money taking spoonfuls long after they've already figured out the flavor.
The Reality: Different soups (quantum circuits) need different amounts of tasting. A simple soup might be understood in 500 spoonfuls, while a complex one might need 50,000. Picking one number for everything is a bad strategy.

The Solution: StableShots (The "Smart Taster")
The paper introduces a new tool called StableShots. Instead of picking a fixed number of spoonfuls in advance, StableShots acts like a smart taster who keeps tasting in small batches and asks a simple question: "Is the soup changing anymore?"

Here is how it works, step-by-step:

Taste in Batches: It takes a small batch of shots (e.g., 50 spoonfuls).
Compare: It compares the current "flavor profile" (the distribution of results) with the profile from a few batches ago.
Check for Stability: If the new batch doesn't change the flavor profile much, it keeps going. But if it sees that the flavor has stopped changing for several batches in a row, it knows the soup is "stable."
Stop: Once it sees this stability happen a few times in a row, it stops the experiment.

Why is this better?
The researchers tested this on 180 different "soups" (quantum circuits) of various sizes and complexities. They compared StableShots against the old "fixed number" method.

The Old Way: Some fixed numbers were too low (giving bad results), and others were too high (wasting time). No single fixed number worked well for everyone.
The StableShots Way: It found the "sweet spot" for every single circuit.
- It reached a high level of accuracy (the flavor was right) for 100% of the tests.
- It did this using a median of 7,650 shots.
- In contrast, the fixed methods either failed to be accurate often or had to use way more shots (like 18,000) to get the same result.

The "Black Box" Advantage
The paper emphasizes that StableShots is a "black box." This means it doesn't need to know the secret recipe of the soup (the circuit's internal math) or the specific quirks of the kitchen (the hardware noise). It only looks at the results it gets. This makes it easy to plug into any quantum computer system without needing special permission or deep technical knowledge.

The Bottom Line
StableShots turns the decision of "how many shots to take" from a guess into a smart, automatic process. It saves time and money by stopping exactly when it has enough information, rather than guessing a number that might be too low or too high. It's like having a taster who knows exactly when the soup is ready, rather than forcing everyone to eat exactly 5,000 spoonfuls regardless of whether the soup is finished or not.

Technical Summary: StableShots: Online Shot Stopping for Quantum Circuit Execution

Problem Statement
Quantum circuit execution relies on repeated measurements (shots) to estimate output distributions. Current workflows typically require developers to pre-define a fixed shot budget (e.g., 1,000 or 10,000 shots). This static approach is described as "brittle": a low budget may under-sample the distribution, leading to poor fidelity, while a high budget wastes computational resources and queue time. The optimal budget is not universal; it depends on the circuit family, size, backend noise, and output sparsity. This issue is framed not merely as a statistical sample complexity problem, but as a quantum software engineering (QSE) challenge regarding how to execute software systematically, measurably, and auditably. The paper focuses specifically on static quantum circuits, where the structure and parameters remain fixed during execution, distinguishing this from variational loops where the target distribution changes by design.

Methodology: STABLESHOTS
The authors propose STABLESHOTS, a lightweight, black-box online stopping rule for static circuit execution. The method operates as a wrapper around standard execution interfaces that return batch-level counts, requiring no inspection of the circuit, backend calibration data, or noise models.

The core mechanism involves:

Batch Execution: The circuit is executed in small batches of $b$ shots.
Monitoring: After each batch, the system computes the Total Variation Distance (TVD) between the current cumulative empirical distribution ( $\hat{P}_N$ ) and a previous cumulative distribution ( $\hat{P}_{N-\ell b}$ ), where $\ell$ is a look-back window in batches.
Stopping Criterion: Execution halts only after observing $k$ consecutive checks where the marginal TVD is below a threshold $\epsilon$ . If stability is not reached, execution continues until a maximum budget $B$ is hit.

The parameters ( $b, \ell, \epsilon, k$ ) control decision granularity, comparison windows, and the conservatism of the stability criterion. The rule is intentionally heuristic; it does not certify that the empirical distribution is within a specific distance of the unknown true backend distribution. Instead, it operationalizes a "diminishing returns" signal: if new batches do not materially change the observed distribution, further sampling is unlikely to alter the developer-visible result.

Experimental Design
The evaluation utilized 180 traces from the QSimBench dataset, covering six circuit families (dj, qaoa, qft, qnn, random, vqe), six sizes (4 to 14 qubits), and five noisy IBM simulated backends.

Reference: A 20,000-shot empirical distribution served as an offline reference for calculating TVD, though STABLESHOTS never observed this during decision-making.
Protocol: The study employed a strict validation/test split with 100 repetitions. In each repetition, one backend was held out as the test set, while the remaining four were used for validation. This ensured the selected configuration was not overfitted to specific backend noise profiles.
Baselines: Performance was compared against fixed-shot budgets of 5,000, 10,000, and 18,000 shots.

Key Results
The selected STABLESHOTS configuration (batches of 50, 3-batch look-back, 5 consecutive stable checks, $\epsilon=0.005$ ) demonstrated superior cost-fidelity trade-offs compared to fixed baselines:

Success Rate: STABLESHOTS achieved a TVD $\le 0.05$ against the reference on 100% of the held-out test evaluations. In contrast, fixed baselines achieved this threshold on only 54.1% (5k shots), 66.7% (10k shots), and 83.3% (18k shots) of evaluations.
Efficiency: The median shot count for STABLESHOTS was 7,650, significantly lower than the 18,000 shots required by the best-performing fixed baseline to achieve similar reliability.
Adaptivity: The method exhibited trace-dependent behavior. Small circuits (4–8 qubits) and specific families (dj, vqe) stopped early with low shot counts. Larger circuits (10–14 qubits) and diffuse distributions (qft, qnn, random) often approached the 20,000-shot cap, correctly identifying that local stability had not yet been achieved.
Failure Mode: When the policy reached the cap, it signaled that the target fidelity could not be met within the budget, providing an informative failure state rather than silently returning an unstable estimate.

Significance and Claims
The paper claims STABLESHOTS as a contribution to Quantum Software Engineering rather than a statistical guarantee of distributional closeness. Its significance lies in:

Auditable Execution: It transforms the shot budget from a pre-execution constant into a traceable execution policy. The stopping decision is derived directly from observed counts, allowing for reproducibility and provenance tracking.
Black-Box Applicability: By relying solely on bitstring counts, the method is compatible with various SDKs, simulators, and hardware providers without requiring internal compiler or hardware knowledge.
Practical Governance: It offers a middle ground between arbitrary low-shot execution and wasteful high-shot fixed budgets. The authors argue that shot count should be treated as a controllable software parameter that can be calibrated, logged, and revised.

The authors remain modest about the scope, noting that the method assumes the backend-induced distribution is stable during execution and that the 20,000-shot reference is finite. They explicitly state that STABLESHOTS does not provide a distribution-free guarantee and that the specific parameter configuration is dataset-scoped, not universally optimal. The work is presented as a tunable policy that supports practical execution governance, with future work suggested for live QPU evaluation, adaptive batch sizing, and application to iterative workloads.

More like this