🧬 biology

The Shot Gap: Bloch-Sphere Geometry and the Hidden Measurement Budget of Single-Qubit Quantum Classifiers

This study reveals a significant "shot gap" between the high thresholded accuracy and the lower single-shot accuracy of single-qubit quantum classifiers, demonstrating that the embedding geometry, rather than measurement choice or boundary nonlinearity, is the primary driver of this discrepancy and arguing that accuracy reports must explicitly state the number of shots used per prediction.

Original authors: Alfredo Merlet

Published 2026-10-21

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Alfredo Merlet

Original paper licensed under CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/). ⚕️ This is an AI-generated explanation of a preprint that has not been peer-reviewed. It is not medical advice. Do not make health decisions based on this content. Read full disclaimer

In the quiet, microscopic world of quantum computing, the simplest possible machine is a single qubit. Think of it not as a tiny computer chip, but as a single, spinning arrow floating in a three-dimensional space. This arrow can point in any direction, and its orientation represents the information it holds. Scientists use these arrows to build classifiers, which are tools designed to sort things into two groups, like separating apples from oranges. To make a decision, the machine rotates the arrow based on the data it receives, and then checks which side of a flat plane the arrow is pointing toward. If it points one way, the machine says "apple"; if the other, "orange."

For years, researchers have evaluated how well these quantum machines work by running the same test thousands of times and averaging the results. This method gives a very high score, suggesting the machine is nearly perfect. However, in the real world, a quantum device often has to make a decision with just one try, using only a single measurement of that spinning arrow. The question that has gone unasked is whether the machine's single-shot performance matches its high average score. If a machine claims to be 95 percent accurate based on thousands of tries, is it actually that good when forced to make a single, final call?

A researcher named Alfredo Merlet set out to answer this by looking at the gap between what these machines promise and what they actually deliver in a single moment. He focused on single-qubit classifiers, the most transparent and fundamental type of quantum model. By simulating these machines with perfect precision, he could compare the idealized, high-score version of the classifier against its single-shot reality. He discovered a significant disconnect, a difference he calls the "shot gap." In his experiments, models that appeared to be 85 to 98 percent accurate when allowed to average many results dropped to between 67 and 86 percent accuracy when forced to decide with just one measurement. This gap was not a small error; it was a substantial drop in performance that averaged about 16 percentage points across many different tasks.

The study revealed that this gap is not caused by a poor choice of how to measure the arrow, nor is it a result of the machine failing to learn the task. Instead, the problem lies in how the information is packed into the arrow's position in the first place. The researchers found that the training methods usually used to teach these machines focus on getting the right answer after many tries, rather than ensuring the arrow points strongly enough to be right the first time. When the machine is trained to maximize its single-shot success, the gap shrinks significantly, though it does not disappear entirely. The study also tested a common assumption that more complex, curved decision boundaries would create larger gaps, but found the opposite to be true; the gap was actually smaller for the most complex tasks because the models struggled to learn them at all, leaving little room for the score to drop further.

Perhaps the most practical finding is that the number of times a machine is asked to repeat a measurement matters more than the model's architecture. The researchers showed that if a machine trained for a single shot is allowed just eleven measurements, it can recover most of the accuracy lost in that single-shot scenario. However, if the machine is trained to optimize for the high, averaged score, it requires roughly ten times as many measurements to reach the same level of confidence. This suggests that the way we currently report the success of quantum classifiers is misleading. A score of 98 percent is only true if the machine is allowed to repeat the experiment hundreds of times, a luxury that may not exist in real-world applications.

The work serves as a reminder that in quantum computing, as in many other fields, the context of a measurement defines the result. The researchers argue that future reports on quantum machine learning should always state how many measurements were taken to achieve a given accuracy, just as they currently report the amount of data used for training. Without this context, a high score tells only half the story. The study confirms that while these tiny quantum machines can learn complex patterns, their ability to make a reliable decision in a single instant is limited by the geometry of their internal state, a limit that no amount of clever measurement can fully overcome. The gap is real, it is measurable, and it is a property of the machine itself, waiting to be accounted for in how we build and judge the next generation of quantum intelligence.

Technical Summary: The Shot Gap in Single-Qubit Quantum Classifiers

Problem Statement
Single-qubit data re-uploading classifiers map input data to points on the Bloch sphere, where decision boundaries are formed by interleaving data-dependent and trainable rotations. Standard evaluation protocols estimate the expectation value of a measured observable (typically $\langle Z \rangle$ ) by averaging over many circuit repetitions ("shots") and thresholding the result. This reported accuracy ( $A_\infty$ ) presupposes an unlimited measurement budget. However, in practical inference scenarios where only a single preparation and measurement are available, the classifier's performance is fundamentally limited by quantum state discrimination theory. Specifically, the probability of a correct guess from a single copy of an unknown state is bounded by the Helstrom limit ( $A_H$ ), which depends solely on the separation between the class-conditional mean Bloch vectors.

The paper identifies a discrepancy between the standard thresholded accuracy and the achievable single-shot accuracy, termed the shot gap ( $A_\infty - A_1$ ). The central problem is quantifying this gap, determining its sources (embedding geometry vs. measurement choice), and evaluating whether standard training losses optimize for single-shot performance.

Methodology
The study employs a controlled computational experiment using exact simulations to eliminate hardware noise and statistical uncertainty.

Tasks and Data: Four synthetic binary classification tasks with known ground truth (linear, circle, XOR, and 4×4 checkerboard boundaries) were generated using inputs uniformly drawn from $[-1, 1]^2$ . Label noise was introduced at levels of 0% and 10%.
Model Architecture: A single-qubit data re-uploading classifier with depth $L \in \{1, 2, 3, 4, 6\}$ . Each layer consists of $R_z R_y R_z$ rotations with trainable parameters.
Training Regime: A factorial design of 1,200 runs crossing 4 tasks, 5 depths, 3 training losses, 2 noise levels, and 10 random seeds.
- Losses compared: Fidelity cost (squared error), Single-shot log-likelihood (negative log-probability of a correct single measurement), and Smoothed hinge loss (optimizing the sign of $\langle Z \rangle$ ).
Metrics and Validation:
- $A_1$ : Single-shot accuracy (outcome of one measurement).
- $A_H$ : The Helstrom bound, calculated analytically from the class-mean Bloch vectors ( $\bar{r}_0, \bar{r}_1$ ).
- $A_\infty$ : Thresholded accuracy (limit of infinite shots).
- $A_S$ : Accuracy with $S$ shots via majority vote.
- Validation: Gradients were verified against finite differences; the Bloch-sphere simulator was validated against explicit state-vector unitary simulations; and the Helstrom bound was cross-checked against a brute-force search over measurement directions.

Key Contributions

Decomposition of Single-Shot Shortfall: The paper provides a closed-form decomposition of the error ( $1 - A_1$ $1 - A_{1}$ ) into two non-negative components:
- Embedding Loss ( $1 - A_H$ ): The error due to the geometric spread of the embedded states (how well the classes are separated on the Bloch sphere).
- Measurement Loss ( $A_H - A_1$ ): The error due to the trained measurement axis not aligning perfectly with the optimal Helstrom measurement.
Quantification of the Shot Gap: The study measures the gap across a wide parameter space, revealing that for models with depth $\geq 2$ , the single-shot accuracy is significantly lower than the reported thresholded accuracy.
Hypothesis Testing: Four preregistered hypotheses were tested:
- H1: $A_1 \leq A_H$ (Validated in all 1,200 runs).
- H2: The gap increases with decision boundary nonlinearity (Not supported; the gap was smallest for the most nonlinear task, the checkerboard, due to poor learnability).
- H3: Class-mean Bloch vector length predicts the gap better than training loss (Not supported; training loss was a stronger predictor).
- H4: Single-shot log-likelihood yields a smaller gap than other losses (Supported).

Results

Magnitude of the Gap: For circuits of depth two or more, models with an average thresholded accuracy of 0.857 achieved only 0.696 accuracy per single shot, resulting in a mean shot gap of 0.161. At depth six, models achieving 0.93–0.98 thresholded accuracy on linear, circle, and XOR tasks delivered only 0.67–0.86 per shot.
Source of the Gap: The embedding loss accounted for 96.3% of the single-shot shortfall. The trained measurement was nearly Helstrom-optimal in every run; the limitation was the geometry of the embedded states, not the choice of measurement basis.
Impact of Training Loss:
- The Smoothed Hinge Loss, which optimizes the conventional thresholded score, produced the largest shot gaps (0.26–0.29 on linear/circle/XOR tasks).
- The Single-shot Log-Likelihood narrowed the gap relative to the hinge loss in 89% of paired configurations (median reduction of 0.085) with a negligible cost in thresholded accuracy (median loss of 0.011).
Shot Budget Recovery: To recover 74% of the shot gap, 11 shots were required under the single-shot log-likelihood, compared to 41% recovery under the hinge loss. A model trained for the thresholded score requires roughly an order of magnitude more shots to approach its reported accuracy.

Significance and Claims
The paper argues that the standard reporting of quantum classifier accuracy is misleading if the shot budget is not specified. The "shot gap" represents a fundamental resource cost: a model reporting 0.98 accuracy may only deliver 0.72 accuracy in a single-shot inference setting.

The author claims three practical implications:

Auditability: The Helstrom bound of a trained single-qubit classifier is cheap to audit, requiring only the estimation of mean Bloch vectors ( $X, Y, Z$ ) without access to the circuit internals.
Reporting Standards: Accuracy reports for quantum classifiers must state the number of shots per prediction, analogous to stating training data size or compute resources.
Loss Function Selection: For applications intended for single-shot or few-shot use, training with the single-shot log-likelihood is superior, as it substantially reduces the gap with minimal penalty to the thresholded score.

The study explicitly limits its scope to single-qubit classifiers with exact simulation, noting that hardware noise would likely exacerbate the gap. It does not claim quantum advantage but rather highlights a methodological gap in how quantum machine learning models are evaluated and reported.

Technical Summary: The Shot Gap in Single-Qubit Quantum Classifiers

More like this