Gate Fidelity

Gate fidelity quantifies the gap between the gate a quantum processor intends to apply and the gate it actually applies. A perfect CNOT has fidelity 1.0. A real superconducting CNOT might have fidelity 0.995, meaning roughly 0.5% of operations go wrong in some way. That small error per gate compounds across a circuit: a 1,000-gate circuit with 99.5% fidelity per gate retains only $(0.995)^{1000} \approx 0.7\%$ of ideal signal. Fidelity is therefore the central metric determining whether a device can run useful circuits.

The details

Single-qubit vs two-qubit fidelity. Single-qubit gates (X, H, Rz) typically achieve fidelities of 99.9% to 99.99% on leading hardware. Two-qubit gates (CNOT, CZ, MS) are roughly 10x worse, sitting at 99% to 99.9% on the best current systems. Two-qubit gates are harder because they require physical coupling between qubits, a channel that also introduces cross-talk and decoherence. Circuit depth is bounded mainly by how many two-qubit gates can be stacked before error accumulation overwhelms the computation.

Gate fidelity and circuit success probability. For a circuit of $d$ two-qubit gates each with fidelity $F$, the success probability decays roughly as $F^d$. At $F = 0.999$ and $d = 1000$, the probability is $(0.999)^{1000} \approx 37\%$. At $F = 0.99$, the same depth gives only $0.004\%$. This exponential sensitivity is why even small fidelity improvements matter enormously for circuit depth.

Randomized benchmarking (RB). The standard technique for measuring average gate fidelity is randomized benchmarking. The protocol applies random sequences of Clifford gates of increasing length, then appends the inverse of the whole sequence. An ideal circuit should return the input state exactly; deviations reveal the per-gate error rate. RB averages over many random circuits, making the measurement insensitive to state preparation and measurement (SPAM) errors. The result is the average gate fidelity $F$ or equivalently the error per Clifford $\epsilon = 1 - F$.

Process fidelity vs average gate fidelity. Process fidelity (or entanglement fidelity) measures the overlap between the ideal and actual quantum channels as superoperators. Average gate fidelity is related by:

$F_{\text{avg}} = \frac{d \cdot F_{\text{proc}} + 1}{d + 1}$

where $d = 2^n$ is the Hilbert space dimension. For a single qubit ($d = 2$), $F_{\text{avg}} = \frac{2F_{\text{proc}} + 1}{3}$. Average gate fidelity is the more operationally meaningful number because it averages over uniformly random input states.

Cross-entropy benchmarking (XEB). Google uses XEB instead of RB. Random circuits are run on hardware, and the output distribution is compared against ideal simulation using the cross-entropy:

$F_{\text{XEB}} = 2^n \langle P_{\text{ideal}}(x) \rangle_{\text{hardware}} - 1$

where the expectation is over hardware measurement outcomes $x$ weighted by their ideal probabilities. XEB is efficient for large systems where full process tomography is intractable. Google used XEB in their 2019 supremacy claim.

Fidelity by platform (approximate, as of 2025):

Platform	Single-qubit fidelity	Two-qubit fidelity
IBM Heron (superconducting)	99.9%	99.5%
Quantinuum H2 (trapped ion)	99.99%	99.9%
IonQ Forte (trapped ion)	99.9%	99.5%
Google Sycamore (superconducting)	99.9%	99.4%

Fidelity thresholds and error correction. The surface code has a fault-tolerance threshold of approximately 99% two-qubit gate fidelity. Below that threshold, adding more error correction makes things worse, not better. Above it, increasing code distance exponentially suppresses logical error rates. Current leading platforms are above threshold, but the overhead remains large: achieving a logical error rate of $10^{-10}$ from physical fidelity of 99.9% still requires thousands of physical qubits per logical qubit.

State preparation and measurement (SPAM) errors. Fidelity benchmarks must separate gate errors from errors when initializing qubits or reading them out. A qubit initialized to $|0\rangle$ may have a 0.5% chance of thermal population in $|1\rangle$; a measurement may misclassify states with similar probability. Randomized benchmarking is specifically designed to be insensitive to SPAM errors, making it a cleaner measure of gate quality than naive circuit-level estimates. SPAM errors are typically in the range of 0.1% to 1% on current hardware and are reported separately.

Why two-qubit gates are harder. Single-qubit gates act on one qubit in isolation and are implemented with microwave pulses (superconducting) or focused laser beams (trapped ion) that are relatively easy to calibrate precisely. Two-qubit gates require a physical coupling mechanism: capacitive or inductive coupling in superconducting qubits, or shared phonon modes in trapped ions. These coupling channels are also the channels through which environmental noise enters, making two-qubit gate calibration a central engineering challenge. Reducing two-qubit gate error rates is among the most important current goals in quantum hardware development.

Fidelity decay and circuit depth budget. System architects use fidelity to set a depth budget: given a target success probability (say 50%), the maximum circuit depth is $d = \log(0.5) / \log(F_{2Q})$. At $F_{2Q} = 0.999$, this gives roughly 693 two-qubit gates; at $F_{2Q} = 0.99$, only about 69. Error correction is the mechanism that breaks this depth barrier, but it requires crossing the fault-tolerance threshold first.

Why it matters for learners

Gate fidelity sets hard limits on circuit depth. A circuit with 500 two-qubit gates at 99% fidelity has a success probability of $(0.99)^{500} \approx 0.7\%$, making it impractical without error correction. Understanding fidelity requirements helps assess which algorithms are executable today and which need fault-tolerant machines. It also explains why improving two-qubit gate fidelity is at least as important as increasing qubit count, and why platform comparisons should always report two-qubit fidelity, not just qubit numbers.

Hardware announcements that lead with qubit count while omitting gate fidelity figures should be treated with skepticism. The most useful hardware comparisons combine gate fidelity, qubit count, connectivity, and speed metrics like CLOPS together to give a realistic picture of what a device can actually compute.

Common misconceptions

Misconception 1: High qubit count compensates for low fidelity. Fidelity and qubit count are independent. A 1,000-qubit processor with 98% two-qubit fidelity cannot run algorithms that a 50-qubit processor with 99.9% fidelity can run reliably. Fidelity determines circuit depth; qubit count determines circuit width. Both matter.

Misconception 2: 99% fidelity is almost perfect. A 1% error rate per gate is catastrophically high for useful computation. A 100-gate circuit would have only a 37% chance of succeeding. “High fidelity” in the context of fault-tolerant computing means 99.9% or above for two-qubit gates, and even that requires substantial error correction overhead.

Misconception 3: Randomized benchmarking gives the fidelity of a specific gate. RB measures the average fidelity over all Clifford gates in the gate set. Specific gates (especially multi-qubit gates between particular qubit pairs) may have fidelities that differ significantly from the average. Interleaved RB can isolate specific gates, but this requires additional protocol runs.

See also

• Quantum Error Correction
• Surface Code
• Quantum Volume
• T1 and T2 Times
• Noisy Intermediate-Scale Quantum (NISQ)