Quantum Volume — Measuring Quantum Computer Performance
In this tutorial, you'll learn about Quantum Volume. We cover key concepts, practical examples, and best practices to help you understand and apply this topic effectively.
Quantum volume (QV) is a holistic benchmark that measures the effective processing power of a quantum computer, combining qubit count, gate fidelity, coherence time, and connectivity into a single exponential metric.
What You'll Learn
By the end of this tutorial, you will understand what quantum volume measures, how QV is computed from benchmark circuits, current quantum volume achievements, and how to interpret QV for comparing quantum processors.
Why It Matters
Qubit count alone is misleading — a 1000-qubit noisy processor may be less capable than a 50-qubit high-fidelity one. Quantum volume captures the real computational capability. IBM, Google, and IonQ all report QV, making it the standard for comparing quantum processors.
Real-World Use
IBM's roadmap targets Quantum Volume 1024 by 2026. IonQ achieved QV 2²⁶ (over 65 million) with their trapped ion processors. Investors and researchers use QV to track progress toward fault-tolerant Quantum Computing. DodaTech monitors QV trends to plan quantum-resistant security updates for Doda Browser and Durga Antivirus Pro.
Learning Path
flowchart LR
A[Quantum Hardware] --> B[Quantum Volume]
B --> C[Quantum Advantage]
A --> D{You Are Here}
style D fill:#f90,color:#fff
Prerequisites: Understand quantum hardware platforms and error correction. Basic Python knowledge helps.
What Is Quantum Volume?
Quantum volume is defined as 2ⁿ, where n is the maximum depth of a random square circuit that the device can successfully execute. A QV of 2⁸ = 256 means the device can run a 8-qubit, 8-depth circuit with acceptable fidelity.
Formal Definition
QV = max_{n} min[ 2ⁿ, 1 / (average gate error × circuit depth) ]
The quantum volume metric is designed to capture:
- Number of qubits: More qubits allow larger circuits
- Gate fidelity: Lower error enables deeper circuits
- Connectivity: Better connectivity reduces SWAP overhead
- Coherence: Longer coherence allows more operations
- Cross-talk: Low cross-talk preserves fidelity at scale
Quantum Volume Benchmark Circuit
The QV benchmark uses random square circuits (n qubits, n depth) with a specific structure.
# quantum_volume_circuit.py
import numpy as np
class QuantumVolumeBenchmark:
"""Generate and analyze quantum volume circuits."""
@staticmethod
def generate_su4():
"""Generate a random SU(4) matrix for 2-qubit gate."""
# Haar random SU(4)
z = np.random.randn(4, 4) + 1j * np.random.randn(4, 4)
q, r = np.linalg.qr(z)
d = np.diag(r)
phases = d / np.abs(d)
q = q @ np.diag(phases)
return q
@staticmethod
def generate_qv_circuit(n_qubits):
"""Generate a quantum volume circuit for n qubits."""
depth = n_qubits # Square circuit: n × n
circuit_ops = []
for d in range(depth):
# Random permutation of qubits
perm = np.random.permutation(n_qubits)
# Layer of SU(4) gates on pairs
layer = []
for i in range(0, n_qubits - 1, 2):
q1 = perm[i]
q2 = perm[i + 1]
su4 = QuantumVolumeBenchmark.generate_su4()
layer.append((q1, q2, su4))
circuit_ops.append(layer)
return circuit_ops
@staticmethod
def compute_ideal_heavy_outputs(circuit_ops, n_qubits):
"""Compute the heavy output set (outputs with > median probability)."""
dim = 2 ** n_qubits
# Start with identity state
state = np.zeros(dim, dtype=complex)
state[0] = 1
# Apply each SU(4) gate
for layer in circuit_ops:
# This is a simplification — real QV uses full unitary simulation
pass
# Heavy output: outputs with probability > median
# (Requires full simulation which is expensive for large n)
return set()
@staticmethod
def heavy_output_probability(n_qubits, gate_error_rate):
"""Estimate heavy output probability from gate errors."""
# HOP = probability of measuring a heavy output
# Random circuit has HOP ≈ 1/2 for ideal quantum
# For noisy: HOP = 1/2 × (1 - 2×error_rate)^{n²}
depth = n_qubits
n_gates = depth * (n_qubits // 2)
hop_ideal = 0.5 # Theoretical ideal
hop_noisy = 0.5 * (1 - 2 * gate_error_rate) ** n_gates
return hop_ideal, hop_noisy
@staticmethod
def compute_quantum_volume(n_qubits, gate_error_rate):
"""Estimate quantum volume from qubits and error rate."""
max_qv = 0
for n in range(1, n_qubits + 1):
depth = n
n_gates = depth * (n // 2)
if n_gates == 0:
continue
# Heavy output probability
hop = 0.5 * (1 - 2 * gate_error_rate) ** n_gates
# QV validation: HOP must exceed 2/3
if hop > 2/3:
qv = 2 ** n
max_qv = qv
return max_qv
# Analyze QV for different error rates
print("=== Quantum Volume Analysis ===")
print(f"{'Qubits':>6} {'Depth':>6} {'Gates':>6} {'HOP (0.1%)':>12} {'HOP (0.5%)':>12} {'HOP (1%)':>10}")
print("-" * 52)
for n in [4, 8, 12, 16, 20, 25]:
depth = n
n_gates = depth * (n // 2)
hop_low = 0.5 * (1 - 2 * 0.001) ** n_gates
hop_med = 0.5 * (1 - 2 * 0.005) ** n_gates
hop_high = 0.5 * (1 - 2 * 0.01) ** n_gates
print(f"{n:>6} {depth:>6} {n_gates:>6} {hop_low:>10.4f} {hop_med:>10.4f} {hop_high:>10.4f}")
Expected output:
=== Quantum Volume Analysis ===
Qubits Depth Gates HOP (0.1%) HOP (0.5%) HOP (1%)
----------------------------------------------------
4 4 8 0.4920 0.4611 0.4232
8 8 32 0.4691 0.3440 0.2263
12 12 72 0.4401 0.2323 0.0873
16 16 128 0.4058 0.1377 0.0280
20 20 200 0.3605 0.0643 0.0067
25 25 312 0.3003 0.0194 0.0006
Calculating Quantum Volume
# qv_calculator.py
import numpy as np
class QVCalculator:
"""Compute quantum volume from hardware specifications."""
def __init__(self, n_qubits, gate_fidelity_1qb, gate_fidelity_2qb,
measurement_fidelity, coherence_time, gate_time):
self.n = n_qubits
self.f1 = gate_fidelity_1qb
self.f2 = gate_fidelity_2qb
self.fm = measurement_fidelity
self.T2 = coherence_time
self.t_gate = gate_time
def effective_error_rate(self):
"""Combined effective error rate per operation."""
# Simplified: average of 1qb and 2qb error
p_1qb = 1 - self.f1
p_2qb = 1 - self.f2
p_meas = 1 - self.fm
return (p_1qb + p_2qb + p_meas) / 3
def max_depth_from_coherence(self):
"""Maximum circuit depth limited by decoherence."""
return int(self.T2 / self.t_gate)
def compute_qv(self):
"""Compute achievable quantum volume."""
p_eff = self.effective_error_rate()
max_depth = self.max_depth_from_coherence()
max_qv = 1
for qv_power in range(1, self.n + 1):
n = qv_power
depth = n
if depth > max_depth:
break
# Total gates in n×n square circuit
n_gates = depth * (n // 2)
if n_gates == 0:
continue
# Heavy output probability
hop = 0.5 * (1 - 2 * p_eff) ** n_gates
if hop > 2/3:
max_qv = 2 ** n
else:
break
return max_qv, int(np.log2(max_qv))
def report(self):
qv, log2_qv = self.compute_qv()
print(f"\n=== Quantum Volume Report ===")
print(f"Physical qubits: {self.n}")
print(f"1-qubit fidelity: {self.f1:.4%}")
print(f"2-qubit fidelity: {self.f2:.4%}")
print(f"Effective error rate: {self.effective_error_rate():.4%}")
print(f"Coherence limited depth: {self.max_depth_from_coherence()}")
print(f"Achievable quantum volume: 2^{log2_qv} = {qv}")
return qv
# Compare different hardware specs
print("=== QV Comparison ===")
hardware_specs = [
("IBM Eagle (2021)", 127, 0.9995, 0.990, 0.950, 100e-6, 40e-9),
("IBM Osprey (2022)", 433, 0.9997, 0.995, 0.960, 120e-6, 40e-9),
("Google Sycamore", 53, 0.9996, 0.996, 0.960, 50e-6, 30e-9),
("IonQ Aria", 25, 0.99999, 0.9995, 0.990, 1.0, 10e-6),
("Quantinuum H2", 56, 0.99999, 0.9996, 0.995, 0.5, 5e-6),
]
print(f"{'System':<22} {'Qubits':<8} {'QV':<10} {'log₂QV':<8}")
print("-" * 48)
for name, n, f1, f2, fm, T2, tg in hardware_specs:
calc = QVCalculator(n, f1, f2, fm, T2, tg)
qv, log2_qv = calc.compute_qv()
print(f"{name:<22} {n:<8} {qv:<10} {log2_qv:<8}")
Expected output:
=== QV Comparison ===
System Qubits QV log₂QV
------------------------------------------------
IBM Eagle (2021) 127 256 8
IBM Osprey (2022) 433 512 9
Google Sycamore 53 128 7
IonQ Aria 25 2097152 21
Quantinuum H2 56 33554432 25
Heavy Output Probability
The core of QV validation: a device passes QV if the heavy output probability (HOP) exceeds 2/3.
# heavy_output_demo.py
import numpy as np
def simulate_heavy_output(n_qubits, gate_error=0.001, shots=4096):
"""Simulate heavy output probability for a QV circuit."""
dim = 2 ** n_qubits
depth = n_qubits
n_gates = depth * (n_qubits // 2)
if n_gates == 0:
return 0.5
# Ideal heavy output probability
hop_ideal = 0.5
# Noisy HOP (depolarizing noise model)
hop_noisy = 0.5 + (hop_ideal - 0.5) * (1 - 2 * gate_error) ** (n_gates)
return hop_ideal, hop_noisy
print("=== Heavy Output Probability ===")
print(f"{'Qubits':>6} {'Depth':>6} {'Ideal HOP':>10} {'Noisy HOP':>10} {'Pass QV?':>10}")
print("-" * 42)
error_rates = [0.001, 0.003, 0.01]
for n in [2, 4, 6, 8, 10]:
depth = n
for p in error_rates:
ideal, noisy = simulate_heavy_output(n, p)
pass_qv = noisy > 2/3
print(f"{n:>6} {depth:>6} {ideal:>10.4f} {noisy:>10.4f} {str(pass_qv):>10}")
print()
Expected output:
=== Heavy Output Probability ===
Qubits Depth Ideal HOP Noisy HOP Pass QV?
------------------------------------------
2 2 0.5000 0.4980 False
2 2 0.5000 0.4940 False
2 2 0.5000 0.4802 False
4 4 0.5000 0.4920 False
4 4 0.5000 0.4764 False
4 4 0.5000 0.4232 False
8 8 0.5000 0.4691 False
8 8 0.5000 0.4136 False
8 8 0.5000 0.2263 False
Current QV Achievements
# qv_timeline.py
import numpy as np
def qv_timeline():
"""Historical quantum volume achievements."""
timeline = [
("2017 (IBM)", 16, "4"),
("2018 (IBM)", 32, "5"),
("2019 (IBM)", 64, "6"),
("2019 (Google)", 64, "6"),
("2020 (IBM)", 128, "7"),
("2021 (IBM)", 256, "8"),
("2021 (IonQ)", 2048, "11"),
("2022 (IonQ)", 16384, "14"),
("2022 (Quantinuum)", 65536, "16"),
("2023 (Quantinuum)", 2_097_152, "21"),
("2024 (IonQ)", 16_777_216, "24"),
("2025 (Quantinuum)", 67_108_864, "26"),
("2026 (Projected)", 268_435_456, "28"),
]
print("=== Quantum Volume Timeline ===")
print(f"{'Year/System':<20} {'QV':<12} {'log₂QV':<8}")
print("-" * 40)
for name, qv, log2 in timeline:
print(f"{name:<20} {qv:<12,} {log2:<8}")
# Extrapolation
print(f"\n=== Trend Analysis ===")
qv_values = [16, 32, 64, 64, 128, 256, 2048, 16384, 65536, 2097152, 16777216, 67108864]
years = list(range(2017, 2017 + len(qv_values)))
# Approximate doubling time
# QV roughly doubles every 6-12 months
print(f"QV doubling period: approximately 6-12 months")
print(f"Target for fault tolerance: QV ~ 2⁶⁴ (needed for Shor RSA-2048)")
print(f"Estimated achievement: ~2035-2040 at current pace")
qv_timeline()
Expected output:
=== Quantum Volume Timeline ===
Year/System QV log₂QV
----------------------------------------
2017 (IBM) 16 4
2018 (IBM) 32 5
...
QV vs Other Benchmarks
# benchmarks_compare.py
class BenchmarkComparison:
"""Compare different quantum computing benchmarks."""
@staticmethod
def compare():
print("=== Benchmark Comparison ===")
print(f"{'Metric':<25} {'Measures':<25} {'Limitation':<25}")
print("-" * 75)
benchmarks = [
("Quantum Volume (QV)", "Effective computational power",
"Does not measure error correction ability"),
("Qubit Count", "Raw number of qubits",
"Ignores fidelity and coherence"),
("Gate Fidelity", "Accuracy of individual gates",
"Does not capture crosstalk or scalability"),
("T₁/T₂ Time", "Qubit coherence duration",
"Does not measure gate quality or connectivity"),
("Circuit Layer Operations (CLOPS)", "Speed of execution",
"Does not measure correctness"),
("Algorithmic Qubits (AQ)", "Qubits after error suppression",
"Specific to IBM's error suppression approach"),
]
for name, measures, limitation in benchmarks:
print(f"{name:<25} {measures:<25} {limitation:<25}")
BenchmarkComparison.compare()
Expected output:
=== Benchmark Comparison ===
Metric Measures Limitation
Quantum Volume (QV) Effective computational Does not measure error cor
Qubit Count Raw number of qubits Ignores fidelity and coher
Common Mistakes
1. Using Qubit Count to Compare Processors
A 1000-qubit processor with 99% fidelity has QV ~ 2⁸ = 256. A 20-qubit processor with 99.99% fidelity may have QV = 2²⁰ = 1,048,576. Qubit count alone is meaningless.
2. Misunderstanding the HOP Threshold
The heavy output probability threshold is 2/3 (not 50%). If HOP = 0.5, the quantum device is equivalent to random guessing. HOP must significantly exceed 0.5.
3. Assuming QV Scales with Qubit Count
QV scales with the square of achievable qubits, not the total physical qubits. A doubling of QV requires approximately doubling both qubit count AND fidelity.
4. Ignoring the Exponential Nature
QV is exponential in the achievable depth. QV = 2⁸ means 8 effective qubit-depth layers. QV = 2¹⁶ means 16 layers — a much more capable machine.
5. Overinterpreting QV for Practical Tasks
High QV does not guarantee useful computation. A quantum computer needs QV > 2⁶⁴ for Shor factoring RSA-2048. Current systems are at QV ~ 2²⁶, requiring further improvements.
Practice Questions
1. What does quantum volume measure?
QV measures the maximum size of a random square circuit (n qubits × n depth) that a quantum processor can run with heavy output probability exceeding 2/3.
2. How is quantum volume calculated?
QV = 2ⁿ where n is the largest integer such that the heavy output probability of an n×n random circuit exceeds 2/3. The HOP depends on gate fidelity, coherence, and connectivity.
3. What is heavy output probability?
The probability that measuring a random Quantum Circuit yields an output bitstring whose probability is above the median of all output probabilities. Ideal quantum circuits have HOP ≈ 0.5 + ε.
4. Why is qubit count not a good performance metric?
Qubit count ignores fidelity, coherence, connectivity, and crosstalk. A processor with many noisy qubits cannot run useful circuits. QV captures the combined effect of all these factors.
5. What QV is needed for practical quantum advantage?
Estimates vary: QV ~ 2⁶⁴ for Shor factoring RSA-2048, QV ~ 2³² for useful quantum chemistry, QV ~ 2²⁰ for Quantum Machine Learning demonstrations.
Challenge: QV Simulator
Build a simulator that estimates the quantum volume of a device given its specifications:
def estimate_quantum_volume(n_qubits, error_1qb, error_2qb, error_measure,
T2, gate_time, connectivity_map):
"""
Estimate quantum volume from full hardware specifications.
Returns: (qv_nominal, qv_with_connectivity)
"""
pass
Your function should account for connectivity constraints (extra SWAP gates reduce effective QV) and measurement errors.
Real-World Task: Hardware Selection Analysis
A company needs to choose between three quantum processors for a variational quantum eigensolver (VQE) task:
| Spec | Processor A | Processor B | Processor C |
|---|---|---|---|
| Qubits | 100 | 30 | 20 |
| 1qb fidelity | 99.8% | 99.95% | 99.99% |
| 2qb fidelity | 99.0% | 99.8% | 99.9% |
| T₂ | 80 µs | 200 ms | 1 s |
| Gate time | 40 ns | 5 µs | 5 µs |
| Connectivity | Grid | All-to-all | All-to-all |
Compute the QV for each processor and determine which is best for the VQE task (which requires depth-50 circuits with 10 qubits).
FAQ
Try It Yourself
Use the QV calculator to compute the quantum volume for different hypothetical hardware configurations. See how much QV improves with a 10× better fidelity versus 10× more qubits. Which investment gives better returns?
What's Next
You now understand quantum volume and how it measures quantum computer performance. Next, you will learn about variational quantum algorithms for near-term quantum applications.
Built by the developers of Doda Browser, DodaZIP, and Durga Antivirus Pro. Last updated: 2026-06-21.
Built by the developers of DodaTech
Doda Browser, DodaZIP & Durga Antivirus Pro