Feed a problem to a laptop and it gives you one answer. Feed the same circuit to a quantum computer and it hands you a pile of them, often ten thousand results for a single program. This is not a bug or a sign of an unfinished machine. It is baked into how a qubit works. Each individual run, called a shot, produces one string of zeros and ones. The real answer lives in how often each string shows up.
Measurement destroys the picture
While a quantum program runs, its qubits hold a superposition, a blend of possibilities weighted by numbers called amplitudes. That rich internal state is where the computing happens. But you cannot read it directly. The moment you measure a qubit, it collapses to a plain 0 or 1, and the probabilities that governed the collapse vanish with it. One measurement is like glancing at a spinning roulette wheel for a single frame and seeing where the ball happened to land. It tells you something, but not the odds.
To recover the odds, you spin again. And again. Each shot resets the qubits, reruns the identical sequence of gates, and measures. Do this enough times and the frequencies converge on the underlying probabilities the circuit was designed to produce. A result that should appear 25 percent of the time will, after ten thousand shots, turn up in roughly a quarter of them. The histogram of outcomes is the output.
Why ten thousand and not ten
The number of shots is a statistics problem in disguise. The uncertainty in an estimated probability shrinks with the square root of the shot count. That square root is unforgiving. To cut your error bars in half, you need four times as many shots. To get one extra digit of precision, roughly a hundred times more. A quick sanity check might use a thousand shots. A careful measurement of a chemistry energy or an expectation value might demand a million.
This is why algorithm designers obsess over what they are actually measuring. Many useful quantum algorithms do not want a single winning bitstring. They want an average, an expectation value, some quantity smeared across the whole distribution. Those averages are especially thirsty for shots, because the thing you care about is a subtle bias in noisy coin flips rather than a clear peak.
The time cost adds up
A single shot is fast, often microseconds of gate operations. But a full run is more than gates. The qubits have to be reset to a known state, the circuit executed, every qubit read out, and then the whole system prepared again. On superconducting machines a repetition can take tens to hundreds of microseconds, much of it spent waiting for qubits to settle. Multiply by ten thousand shots, then by the many circuit variants a real workload needs, and a job that sounds instant can run for minutes or hours of wall-clock time.
This overhead is one reason benchmarks like CLOPS, which count how many complete circuit layers a machine executes per second, matter as much as raw qubit numbers. A processor with more qubits that samples slowly may deliver answers no faster than a smaller, nimbler one. Shot throughput is a real bottleneck, and vendors work hard to shave microseconds off reset and readout.
Noise makes the histogram lie
On today's hardware there is a second reason to take many shots: errors. A faulty gate or a misread qubit can nudge a shot into the wrong bin. With enough samples, some error patterns wash out or can be estimated and subtracted, the basis of error mitigation tricks that model the noise and rewind its effect on the averaged result. But mitigation only works if you have enough shots to see the signal through the added variance, which pushes the shot count higher still. More noise means more sampling to reach the same confidence.
Reading the output as a distribution
The deeper point is a shift in mindset. A classical program is deterministic; you trust its single answer. A quantum program is probabilistic by construction, and its output is a shape, not a point. Learning to read that shape, to know when a peak is real and when it is sampling noise, is part of the craft of quantum programming. The machine is not being evasive when it runs your circuit ten thousand times. It is telling you the only kind of truth a qubit knows how to tell.
