MethodLayer 0
Quantum volume from random square circuits
Run random circuits that are as deep as they are wide, and ask how often the machine returns one of the outputs that should be more likely than the median. Widen and deepen together until it can no longer beat that bar; the last size it managed is the number.
A programmable device — its qubits, its native gate set, its connectivity and its measurement — plus how many circuits and how many shots you are willing to spend, and the confidence level the answer has to be established at.
A number characterising the hardware, the protocol that produced it, and the statistical confidence it holds at — never an answer to a computational problem, because no computational problem was posed.
Same contract as the slot it fills.
This one, drawn
From Physical qubits to Number about the machine
A circle is an object you are holding. This method is drawn heavier, opened into its own steps; the other lines between the same two ends are the alternatives recorded for the same slot. Circles are named on hover, and each one is a link.
Nothing drawn here has a recorded way through it that this figure leaves shut. See it on the map
What it fills
- Measure what the machine can actually do
Run a protocol whose answer is already known, on the hardware, and read the machine's own performance off how far the result falls short. Nothing here computes anything a user wanted — the point is that the answer is known in advance, because that is what makes the shortfall a measurement.
When it applies
The circuits are specified exactly: *"Each layer is specified by choosing a uniformly random permutation of the m qubit indices and sampling each U^(t)_{a,b}, acting on qubits a and b, from the Haar measure on SU(4)"*. The bar is a fixed fraction rather than a fitted curve — *"The heavy output generation problem is to produce a set of output strings such that more than two-thirds are heavy"* — and the number is where that bar is last cleared: *"We define the achievable depth d(m) to be the largest d such that we are confident h_d > 2/3"*, giving . What it is claimed to cover is broad and stated: *"This metric takes into account all relevant hardware parameters. This includes the performance parameters (coherence, calibration errors, crosstalk, spectator errors, gate fidelity, measurement fidelity, initialization fidelity) as well as the design parameters such as connectivity and gate set."*
Requires
Every step this method names moves its route along, so there is nothing it needs alongside them.
Example
given a programmable device: n qubits, native gate set, connectivity, a
transpiler that compiles onto it, and a classical simulator able to
compute heavy sets up to the widths under test
a trial budget n_c >= 100 model circuits per (m, d), n_s shots each
a confidence multiplier z = 2 (a 97.5% one-sided bound) (Appendix C, Eq. C2-C3)
requires the model circuit's own form -- this is what makes it "quantum
volume" rather than any other random-circuit test: d layers on m
qubits, each layer a uniformly random permutation pi_t of the m qubit
labels followed by independent Haar-random SU(4) gates on each of the
resulting pairs (Eq. 1)
# when m is odd, one qubit sits idle each layer (Fig. 1 caption)
# --- per (m, d): classify one circuit's outputs as heavy or not -----------
function isHeavy(m, d, n_c, n_s): (Algorithm 1)
n_h <- 0
repeat n_c times:
U <- random model circuit of width m, depth d (Eq. 1)
p_U(x) <- |<x|U|0>|^2 for every bitstring x (Eq. 2)
p_med <- median of the sorted p_U(x)
H_U <- { x : p_U(x) > p_med } (Eq. 3)
# H_U is computed by classically simulating U -- this is the
# part of the protocol that costs exponential classical
# time/space in m, not the run on hardware (footnote 1, after Eq. 2)
U' <- transpiler's compiled U for this device
# the transpiler may use any trick that is an honest attempt at
# U -- it may NOT substitute a simpler operation that merely
# reproduces U's heavy outputs (main text, after Eq. 4)
repeat n_s times:
x <- measured outcome of running U'
if x is in H_U: n_h <- n_h + 1
h_hat_d <- n_h / (n_c * n_s)
bound <- ( n_h - z * sqrt( n_h * (n_s - n_h/n_c) ) ) / (n_c * n_s) (Eq. C3)
return bound > 2/3
# 2/3 is the heavy output generation problem's own fixed threshold,
# not something derived here -- the ideal-device value is
# asymptotically (1 + ln 2)/2 ~= 0.85, and it falls to ~0.5 under
# complete depolarization, so 2/3 sits strictly between the two
# (main text, after Eq. 3, before Eq. 6)
# comparing "bound", not h_hat_d itself, against 2/3 is what turns the
# raw estimate into a claim made at 97.5% one-sided confidence,
# using a normal approximation to the binomial valid because the
# interesting range of h_hat_d sits close to 2/3 (Appendix C)
# --- sweep width and depth, find the largest square that survives --------
for each width m:
d(m) <- largest d such that isHeavy(m, d', n_c, n_s) holds for every
d' = 1, ..., d (Eq. 6)
# a single failure at some d' ends the run for this m -- d(m) is
# defined by an unbroken run from d'=1, not by the best d alone
return log2(V_Q) = argmax over m of min(m, d(m)) (Eq. 7)
# the volume is reported as ONE number for the device: the side length of
# the largest SQUARE (m = d) model circuit it passes on average, taking
# width and depth as equally important by construction (Eq. 7)
# not part of this protocol: any claim that a real algorithm of the same
# size would succeed -- the paper states only that V_Q "loosely
# coincides" with the cost of classically simulating these same random
# circuits, and does not prove the two are equal (discussion after Eq. 7)Cost, as the source states it
The measurement price is written as an algorithm, not proved as a sample-complexity bound. Certifying success at width and depth takes random model circuits, each executed times; with the number of heavy outcomes over all trials, success is claimed only when , taking for a 97.5% one-sided confidence interval. The reported experiments ran 200 circuits per width, with borderline points repeated at 5000 or 1000 circuits; at the observed heavy fraction must exceed . Verification is a separate, classical cost: each circuit's heavy set comes from simulating it, time and space by wave-vector propagation, or space and time by a Feynman algorithm. The paper says only that the volume it defines loosely coincides with this simulation complexity.
Implementations
Quantum volume on four IBM Q devices
The measurement campaign the protocol was introduced with. The five authors, all at IBM T. J. Watson, run it on four IBM Q superconducting transmon processors — 5-qubit Tenerife, 16-qubit Melbourne, 20-qubit Tokyo and 20-qubit Johannesburg — sweeping square model circuits (width m = depth d) upward until the measured heavy-output fraction can no longer be certified above 2/3. The abstract's headline number, "values as high as 16", comes from this campaign.
Square circuits at m = d = 2, 3 and 4 on every device, plus m = d = 5 on Johannesburg, with 200 random model circuits generated at each width. Each sampled SU(4) gate was first expanded into CNOTs and single-qubit gates by the KAK decomposition implemented in Qiskit Terra; the circuit was then mapped to the device by Terra's standard pass sequence — unrolling, swap mapping, a second unrolling to expand the inserted SWAPs, CNOT reorientation, CNOT cancellation, a third unrolling for Hadamards, and single-qubit optimization — into the IBM Q gate set of CNOTs and single-qubit u1/u2/u3 gates. Each circuit's heavy set came from classically simulating the ideal circuit, by a method the paper says scales exponentially in m. Two further passes — a two-qubit block collection pass, and a two-qubit block optimization pass that resynthesises each collected block either exactly by the KAK decomposition or approximately by the scheme of Appendix B — were applied after that standard set only in the study of optimized circuits, meaning Table II's KAK and 1%/3%/5% approximation columns and the m = d = 4† rows of Table I; every unmarked row of Table I is a standard-transpiler circuit. For Tokyo and Johannesburg every swept width was also simulated twice, once ideally and once under a depolarizing noise model driven by average error rates measured on the qubits used on that device, and plotted against the hardware points in Figs. 2 and 3; Tenerife and Melbourne receive no simulated counterpart anywhere in the paper. Success at a width is claimed only when the one-sided bound of Eq. (C3) exceeds 2/3, with z = 2 for a 97.5% one-sided confidence interval and a minimum of n_c = 100 circuits; because that bound is deliberately conservative, the observed heavy fraction itself must clear a stricter threshold set by the number of circuits run — 0.68 at 5000 circuits, 0.695 at 1000. Borderline points were therefore repeated: m = d = 2 on Tenerife and m = d = 3 on Tokyo at 5000 circuits, the optimized m = d = 4 point on Johannesburg at 1000. The counts the paper reports are circuits per width; it defines a per-circuit repetition count n_s but gives no value for it in these runs, and refuses on principle to let repetition relax the threshold. Read Fig. 2's 5000 as circuits: that figure's legend and caption call them "shots" where the main text and Table I's caption call the same repeats circuits.
No dataset in the usual sense — the inputs are randomly generated model circuits, each layer a uniformly random permutation of the m qubit indices followed by Haar-random SU(4) gates on the resulting pairs, with each circuit's ideal heavy set computed by classical simulation. The four qubits used for the m = d = 4 runs are identified per device in Fig. 8; on Johannesburg they form a linear nearest-neighbour topology, which Appendix B says let the authors implement a special-case optimization replacing some gates by their mirrored form to cut the number of inserted SWAP gates. The second input is a set of average error rates over the qubits used, measured one day before the experiments (Table V): Johannesburg 0.4 x 10^-3 single-qubit, 1.1 x 10^-2 CX and 3.9 x 10^-2 measurement, against Tokyo's 1.6 x 10^-3, 2.1 x 10^-2 and 3.0 x 10^-2. These feed the noisy simulations, not the hardware runs.
The paper names no repository for the experiments themselves. The compilation ran on Qiskit Terra, whose passes and decompositions it spells out in Appendices A and B rather than pointing at code. The one artefact it does name is downstream of the runs: the authors state that they have "released a library for measuring quantum volume as an open-source component of Qiskit Ignis". The Qiskit reference that library is cited to carries no URL or DOI.
Measured heavy-output fractions, with the paper's parenthesised uncertainties — it never says what they are. At m = d = 2: Tenerife 0.685(0.001) at 5000 circuits, Melbourne 0.638(0.006), Tokyo 0.718(0.006), Johannesburg 0.711(0.006). At m = d = 3: 0.651(0.006), 0.641(0.009), 0.682(0.002) at 5000 circuits, 0.729(0.007). At m = d = 4: 0.516(0.002), 0.523(0.002), 0.614(0.003), 0.664(0.004). From this the paper reads log2 V_Q = 3 for Tokyo, log2 V_Q = 2 for Tenerife and log2 V_Q < 2 for Melbourne, whose width-2 point is already under 2/3. Johannesburg's plain width-4 point, 0.664, lies just below 2/3; recompiled with the KAK decomposition and the approximate SU(4) synthesis at 1% CX error and repeated with 1000 circuits, the same width returns 0.699(0.001) against that count's 0.695 threshold, while m = d = 5 gives 0.601(0.004). That pair of decompositions did not rescue Tokyo, whose optimized circuits were compiled with the approximate block-optimization pass but without the mirroring special case Johannesburg's linear layout allowed: 28.1 CX gates on average at 0.614(0.003) with the standard transpiler, 21.0 at 0.632(0.005) with KAK, 17.7 at 0.649(0.005) at the 1% approximation — all below 2/3. Those three are Table II's experiment row; the noisy-simulation row directly above them clears 2/3 in every column (0.676 to 0.693), and the paper notes that the noisy depolarizing simulation "substantially over-estimates the performance" relative to the hardware. Johannesburg's optimized point is the only width-4 entry in Table I above its threshold. The conclusion states, of the devices collectively and without naming one, that "we can successfully implement model circuits on up to log2 VQ = 4 qubits, which corresponds to a quantum volume as high as VQ = 16"; the only per-device volumes the paper writes down are Tokyo's, Tenerife's and Melbourne's, and Johannesburg is absent from that list.
Simulated connectivity sweep to 12 qubits
A simulation-only companion in the same paper, run to ask the inverse question: what two-qubit error rate a device would need in order to reach a given quantum volume, and how much of the answer is connectivity. Three coupling maps are compared — all-to-all, square grid and loop — and no hardware is involved.
Model circuits of width m on each coupling graph for up to 12 qubits, all compiled with the standard Qiskit Terra transpiler and simulated under a depolarizing noise model with two-qubit error epsilon, single-qubit error epsilon/10, and perfect measurement; the square grid was additionally run at 1% and 5% measurement error. The error rate quoted for each target volume is the one at which 200 simulated circuits reach a heavy output probability of 0.67 +/- 0.05.
The inputs are model circuits of the same construction as the hardware runs — a uniformly random permutation of the qubit indices per layer, followed by Haar-random SU(4) gates on the resulting pairs — taken at widths up to 12, well past the m = d = 5 the hardware campaign reached, and laid out on the graph under test. For the square grid the m qubits are packed into the largest possible square, with extra qubits added first to a new right column and then to a new bottom row. Nothing measured from a device enters: the two-qubit error epsilon is swept, not taken from hardware.
Maximum permissible two-qubit error to reach log2 V_Q = 4, 6, 8 and 12: all-to-all 0.03, 0.015, 0.008, 0.0032; square grid 0.028, 0.011, 0.005, 0.0015; loop 0.028, 0.011, 0.0047, 0.0014. All-to-all connectivity buys roughly a factor of two at the top of that range — "log2 VQ of 12 is achievable with twice the two-qubit error rate (0.0032) of the square grid (0.0015) and the 12-qubit loop (0.0014)" — while grid and loop barely separate, the loop's requirement being under 7% lower than the grid's in the 12-qubit case. The paper attributes that closeness to the small total number of qubits rather than to the asymptotics, which it says do differ significantly, and adds that the gap may widen even at these sizes under an optimal transpiler. Measurement error is expensive for the grid at the top end: at log2 V_Q = 12 the permissible two-qubit error falls from 0.0015 at 0% measurement error to 0.00125 at 1% and 0.0002 at 5%. The closed-form estimate of Eq. 8 agrees with these simulations down to epsilon of about 10^-3 (Fig. 4).
What it needs
Nobody has taken this apart yet. That is a gap in this graph, not a claim that the method has no parts.
Other ways to fill the same slot
Different approaches
- Randomized benchmarking over Clifford sequences
Apply a random sequence of Clifford gates, then the one gate that undoes all of them, and see how often the machine comes back to where it started. Lengthen the sequence and the return probability decays; the decay rate is the average error a single gate costs, and preparation and measurement errors fall out of the fit rather than contaminating it.
In the Atlas
- Quantum volume from randomized model circuits
Measure, as a single number, how large a random circuit of equal width and depth a given quantum computer successfully implements, so that progress toward improved system-wide gate error rates can be measured and compared across near-term devices.