Single-Qubit Randomized Benchmarking for Average Gate Fidelity

Introduction

Hello again. In our previous lesson, we established the theoretical foundation of randomized benchmarking (RB). We learned how applying sequences of random Clifford gates, followed by an inverse, allows us to measure gate performance. The key insight was that averaging over many such sequences—a process called twirling—transforms any gate-independent Markovian noise into a simple depolarizing channel. This leads to the characteristic exponential decay of the sequence fidelity:

From the fitted decay parameter $p$, we can extract the average Error Per Clifford (EPC), $r=(1-p)/2$ for a single qubit, in a way that is robust to state preparation and measurement (SPAM) errors.

Today, we will transition from theory to practice. Our objective is to implement a single-qubit randomized benchmarking experiment on a noisy simulator to extract the average gate fidelity. This will involve setting up a simulated quantum environment with a defined noise model, running the RB protocol using a modern quantum software framework, and performing the data analysis to extract the key performance metrics.

Preparing the "Noisy Device": A Simulated Backend

Before we can benchmark our gates, we need a quantum processor to run them on. For this lesson, we will use a software simulator. A key advantage of a simulator is that we can precisely define the noise characteristics, allowing us to verify that our RB implementation correctly measures the noise we introduce.

We will use Qiskit, a popular open-source framework for quantum computing. To simulate a realistic, noisy device, we will use Qiskit's AerSimulator and configure it with a NoiseModel. In line with the theory from our last lesson, we will use a depolarizing error model. This model assumes that after each gate, there's a certain probability that the qubit's state is completely randomized.

The code to set up a simple noise model where single-qubit gates (sx, x) have a 0.5% error probability and two-qubit gates (cx) have a 5% error probability looks like this:

# For simulation
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error

# Create an empty noise model
noise_model = NoiseModel()

# Add depolarizing error to single-qubit gates
p_1q_error = 0.005 
noise_model.add_all_qubit_quantum_error(depolarizing_error(p_1q_error, 1), ["sx", "x"])

# Add depolarizing error to two-qubit gates
p_2q_error = 0.05
noise_model.add_all_qubit_quantum_error(depolarizing_error(p_2q_error, 2), ["cx"])

# Create a backend simulator with the noise model
backend = AerSimulator(noise_model=noise_model)

This backend object now represents our simulated noisy quantum computer, ready for characterization.

Implementing the Randomized Benchmarking Experiment

With our noisy backend defined, we can now set up the RB experiment. While one could implement the Clifford generation, inversion, and circuit construction from scratch, modern frameworks like qiskit-experiments provide high-level tools to automate this process.

We will use the StandardRB class, which requires three main parameters that should be familiar from our last lesson:

• qubits: The physical qubit(s) to run the experiment on.
• lengths: A list of sequence lengths, m, to be tested.
• num_samples: The number of different random Clifford sequences, K, to generate and average over for each length m.

As you saw in the resource, after setting the parameters and running exp.run(backend), the library automatically handles:

1. Generating num_samples random Clifford sequences for each length m.
2. Calculating the correct inverse gate for each sequence.
3. Transpiling these logical Clifford operations into the backend's basis gates (e.g., sx, rz).
4. Executing the circuits on the backend.
5. Averaging the "survival probabilities" for each m to get $F_{\text{seq}}(m)$.
6. Fitting the results to the exponential model $F_{\text{seq}}(m)=A_0{\alpha }^m+B_0$.

The analysis produces a plot and a table of results. The plot shows your experimental data points and the best-fit exponential curve—a direct visualization of the theory we discussed. The analysis results provide the fitted parameters, most importantly alpha (our $p$) and the Error Per Clifford (EPC), which is our $r$.

From Error Per Clifford (EPC) to Error Per Gate (EPG)

The EPC is a useful metric, but it tells us the error of an abstract Clifford operation. What we often want to know is the error of the physical, elementary gates that the quantum computer actually executes (e.g., $\pi /2$ rotations like the sx gate). This is the Error Per Gate (EPG).

To convert EPC to EPG, we need to know, on average, how many elementary gates are required to construct a single Clifford gate. Since the Clifford gates are chosen randomly, we need the average number of elementary gates per Clifford, denoted ${\bar{n}}_{\text{gates}}$. If we assume the errors from each elementary gate add incoherently, we can approximate the relationship as:

The value of ${\bar{n}}_{\text{gates}}$ depends on the specific choice of elementary gates and the compiler's efficiency.

As the paper demonstrates, for a basis gate set of $\pi$ and $\pi /2$ rotations around the X and Y axes, the single-qubit Clifford group can be synthesized with an average of ${\bar{n}}_{\text{gates}}=1.875$ elementary gates per Clifford.

Qiskit's StandardRB analysis automates this conversion. It knows the average number of gates per Clifford for its standard basis set (sx, rz, x). Furthermore, it allows for a more nuanced model where you can specify the expected gate_error_ratio. For instance, you might assume virtual rz gates are error-free ('rz': 0), while sx and x gates contribute equally to the error ('sx': 1, 'x': 1). The analysis then distributes the total EPC among the basis gates according to these ratios and their average counts per Clifford, providing an estimated EPG for each basis gate.

Conclusion

In this lesson, we bridged the gap between the theory of randomized benchmarking and its practical implementation. We've seen how to use a software framework to carry out the full RB workflow on a simulated noisy quantum device.

Key Takeaways:

• RB Implementation: The process involves (1) defining a (simulated) noisy backend, (2) using a library like qiskit-experiments to generate and run the RB sequences for various lengths m, and (3) fitting the resulting fidelity decay curve.
• From Fit to Fidelity: The fit to $F_{\text{seq}}(m)=A_0{p}^m+B_0$ yields the depolarizing parameter $p$ (often called alpha), which is then used to compute the Error Per Clifford (EPC).
• EPC vs. EPG: The EPC measures the error of an average Clifford operation. To find the more fundamental Error Per Gate (EPG) for the physical basis gates, we must re-scale the EPC by the average number of elementary gates per Clifford ($\text{EPG}\approx \text{EPC}/{\bar{n}}_{\text{gates}}$).
• Practical Tools: Modern quantum SDKs provide powerful, automated tools for performing complex characterization experiments like RB, handling the low-level details of sequence generation and analysis.

Preview of the next lesson:
Randomized benchmarking provides a single number—the average gate fidelity—which is an incredibly useful and scalable metric. However, it doesn't tell us the whole story. What kind of errors are happening? Is the gate over-rotating, or is it introducing dephasing? To get this level of detail, we need a more comprehensive tool. In the next lesson, we will compare and contrast randomized benchmarking with quantum process tomography, a technique that can reconstruct the full mathematical description of a noisy gate, and discuss the trade-offs between the information they provide and their experimental cost.