Randomized Benchmarking: What a Return-to-Zero Test Says About Gate Errors

Randomized Benchmarking: What a Return-to-Zero Test Says About Gate Errors

Random Clifford gates followed by a recovery should return a qubit to its starting state. The measured decay with sequence length reveals an average error per Clifford.

A quantum circuit can be useful even when its ideal job is to do nothing. Randomized benchmarking deliberately builds complicated-looking circuits whose net ideal operation is the identity. Noise makes their return to the starting state less reliable, and that loss carries information about gate performance.

Random gates with a known ending

Prepare |0⟩. Choose m Clifford operations uniformly at random, apply C_1 first through C_m last, and append one computed recovery Clifford:

R = (C_m ... C_2 C_1)†

The dagger means the adjoint of the entire product. In the absence of errors, R C_m ... C_1 = I, so measurement returns 0 with certainty. The recovery cancels the ideal gate sequence, not the physical noise introduced along the way.

Repeat this for many random sequences and several lengths m. Each circuit also needs repeated shots. Average the fraction of measurements returning 0 to obtain the survival probability at each length.

What the decay parameter means

The usual standard-RB model fits the averaged survival to

P_survival(m) = A α^m + B

The parameters A and B absorb fixed state-preparation, measurement, and recovery effects in the standard model. That is why RB is relatively robust to these fixed offsets, rather than being a method that makes readout errors disappear. The decay parameter α describes the bulk sequence behavior.

Under the usual stationary, gate-independent Markovian noise interpretation, the single-qubit error per Clifford is

EPC = (1 - α)/2

This is not automatically an error per native pulse or basis gate. A Clifford can compile into multiple native gates, and separating their contributions requires additional information or assumptions.

Try the fit without hardware

This example requires NumPy and SciPy. It creates exact synthetic probabilities from the model, then recovers its decay parameter. It is a demonstration of the analysis, not a hardware measurement or a complete benchmarking experiment.

import numpy as np
from scipy.optimize import curve_fit

m = np.array([1, 10, 25, 50, 100, 200], dtype=float)

def rb_curve(m, A, alpha, B):
    return A * alpha**m + B

survival = rb_curve(m, 0.47, 0.992, 0.50)
(A, alpha, B), _ = curve_fit(
    rb_curve, m, survival,
    p0=[0.45, 0.99, 0.5],
    bounds=([0, 0, 0], [1, 1, 1]),
)
print(f"alpha={alpha:.6f}")
print(f"single-qubit EPC={100 * (1 - alpha) / 2:.3f}%")

The output is alpha=0.992000 and single-qubit EPC=0.400%. Real data fluctuate across both shots and random sequences, so a serious result also needs uncertainty estimates and checks that the fit is appropriate.

Correlated noise, drift, leakage outside the qubit subspace, and strong gate dependence can spoil a simple exponential or its interpretation. RB summarizes average behavior under a particular protocol. It does not identify every faulty gate or guarantee that a particular algorithm will succeed.

For practical implementations and interpretation, see the Qiskit Experiments RB guide and the Forest Benchmarking protocol explanation.