Note

This is the documentation for the current state of the development branch of Qiskit Experiments. The documentation or APIs here can change prior to being released.

Randomized Benchmarking

Randomized benchmarking (RB) is a popular protocol for characterizing the error rate of quantum processors. An RB experiment consists of the generation of random Clifford circuits on the given qubits such that the unitary computed by the circuits is the identity. After running the circuits, the number of shots resulting in an error (i.e. an output different from the ground state) are counted, and from this data one can infer error estimates for the quantum device, by calculating the Error Per Clifford. See the Qiskit Textbook for an explanation on the RB method, which is based on Refs. [1] [2].

Note

This tutorial requires the qiskit-aer and qiskit-ibm-runtime packages to run simulations. You can install them with python -m pip install qiskit-aer qiskit-ibm-runtime.

import numpy as np
from qiskit_experiments.library import StandardRB, InterleavedRB
from qiskit_experiments.framework import ParallelExperiment, BatchExperiment
import qiskit.circuit.library as circuits

# For simulation
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime.fake_provider import FakePerth

backend = AerSimulator.from_backend(FakePerth())

Standard RB experiment

To run the RB experiment we need to provide the following RB parameters, in order to generate the RB circuits and run them on a backend:

• qubits: The number of qubits or list of physical qubits for the experiment

• lengths: A list of RB sequences lengths

• num_samples: Number of samples to generate for each sequence length

• seed: Seed or generator object for random number generation. If None then default_rng will be used

• full_sampling: If True all Cliffords are independently sampled for all lengths. If False for sample of lengths longer sequences are constructed by appending additional Clifford samples to shorter sequences. The default is False

The analysis results of the RB Experiment may include:

• EPC: The estimated Error Per Clifford

• alpha: The depolarizing parameter. The fitting function is \(a \cdot \alpha^m + b\), where \(m\) is the Clifford length

• EPG: The Error Per Gate calculated from the EPC, only for 1-qubit or 2-qubit quantum gates (see [3])

Running a 1-qubit RB experiment

The standard RB experiment will provide you gate errors for every basis gate constituting an averaged Clifford gate. Note that you can only obtain a single EPC value \(\cal E\) from a single RB experiment. As such, computing the error values for multiple gates \(\{g_i\}\) requires some assumption of contribution of each gate to the total depolarizing error. This is provided by the gate_error_ratio analysis option.

Provided that we have \(n_i\) gates with independent error \(e_i\) per Clifford, the total EPC is estimated by the composition of error from every basis gate,

\[{\cal E} = 1 - \prod_{i} (1 - e_i)^{n_i} \sim \sum_{i} n_i e_i + O(e^2),\]

where \(e_i \ll 1\) and the higher order terms can be ignored.

We cannot distinguish \(e_i\) with a single EPC value \(\cal E\) as explained, however by defining an error ratio \(r_i\) with respect to some standard value \(e_0\), we can compute EPG \(e_i\) for each basis gate.

\[{\cal E} \sim e_0 \sum_{i} n_i r_i\]

The EPG of the \(i\) th basis gate will be

\[e_i \sim r_i e_0 = \dfrac{r_i{\cal E}}{\sum_{i} n_i r_i}.\]

Because EPGs are computed based on this simple assumption, this is not necessarily representing the true gate error on the hardware. If you have multiple kinds of basis gates with unclear error ratio \(r_i\), interleaved RB experiment will always give you accurate error value \(e_i\).

lengths = np.arange(1, 800, 200)
num_samples = 10
seed = 1010
qubits = [0]

# Run an RB experiment on qubit 0
exp1 = StandardRB(qubits, lengths, num_samples=num_samples, seed=seed)
expdata1 = exp1.run(backend).block_for_results()
results1 = expdata1.analysis_results()

# View result data
print("Gate error ratio: %s" % expdata1.experiment.analysis.options.gate_error_ratio)
display(expdata1.figure(0))
for result in results1:
    print(result)

Gate error ratio: {'x': 1.0, 'rz': 0.0, 'sx': 1.0}

AnalysisResult
- name: @Parameters_RBAnalysis
- value: CurveFitResult:
 - fitting method: least_squares
 - number of sub-models: 1
  * F_rb_decay(x) = a * alpha ** x + b
 - success: True
 - number of function evals: 106
 - degree of freedom: 1
 - chi-square: 2.007055348447676
 - reduced chi-square: 2.007055348447676
 - Akaike info crit.: 3.241497144063736
 - Bayesian info crit.: 1.4003802274234074
 - init params:
  * a = 0.47121259725010955
  * alpha = 0.9996005900366303
  * b = 0.5
 - fit params:
  * a = 0.2269124243217456 ± 0.048618869992295984
  * alpha = 0.9990411621179349 ± 0.0002757776517843253
  * b = 0.7438926546305998 ± 0.049519564743333945
 - correlations:
  * (a, b) = -0.9994437190884107
  * (alpha, b) = -0.9951488897874744
  * (a, alpha) = 0.9922691603177048
- quality: good
- extra: <2 items>
- device_components: ['Q0']
- verified: False
AnalysisResult
- name: alpha
- value: 0.99904+/-0.00028
- χ²: 2.007055348447676
- quality: good
- extra: <2 items>
- device_components: ['Q0']
- verified: False
AnalysisResult
- name: EPC
- value: 0.00048+/-0.00014
- χ²: 2.007055348447676
- quality: good
- extra: <2 items>
- device_components: ['Q0']
- verified: False
AnalysisResult
- name: EPG_x
- value: 0.00062+/-0.00018
- χ²: 2.007055348447676
- quality: good
- extra: <2 items>
- device_components: ['Q0']
- verified: False
AnalysisResult
- name: EPG_rz
- value: 0.0+/-0
- χ²: 2.007055348447676
- quality: good
- extra: <2 items>
- device_components: ['Q0']
- verified: False
AnalysisResult
- name: EPG_sx
- value: 0.00062+/-0.00018
- χ²: 2.007055348447676
- quality: good
- extra: <2 items>
- device_components: ['Q0']
- verified: False

Running a 2-qubit RB experiment

In the same way we can compute EPC for two-qubit RB experiment. However, the EPC value obtained by the experiment indicates a depolarization which is a composition of underlying error channels for 2Q gates and 1Q gates in each qubit. Usually 1Q gate contribution is small enough to ignore, but in case this contribution is significant comparing to the 2Q gate error, we can decompose the contribution of 1Q gates [3].

\[\alpha_{2Q,C} = \frac{1}{5} \left( \alpha_0^{N_1/2} + \alpha_1^{N_1/2} + 3 \alpha_0^{N_1/2} \alpha_1^{N_1/2} \right) \alpha_{01}^{N_2},\]

where \(\alpha_i\) is the single qubit depolarizing parameter of channel \(i\), and \(\alpha_{01}\) is the two qubit depolarizing parameter of interest. \(N_1\) and \(N_2\) are total count of single and two qubit gates, respectively.

Note that the single qubit gate sequence in the channel \(i\) may consist of multiple kinds of basis gates \(\{g_{ij}\}\) with different EPG \(e_{ij}\). Therefore the \(\alpha_i^{N_1/2}\) should be computed from EPGs, rather than directly using the \(\alpha_i\), which is usually a composition of depolarizing maps of every single qubit gate. As such, EPGs should be measured in the separate single-qubit RBs in advance.

\[\alpha_i^{N_1/2} = \alpha_{i0}^{n_{i0}} \cdot \alpha_{i1}^{n_{i1}} \cdot ...,\]

where \(\alpha_{ij}^{n_{ij}}\) indicates a depolarization due to a particular basis gate \(j\) in the channel \(i\). Here we assume EPG \(e_{ij}\) corresponds to the depolarizing probability of the map of \(g_{ij}\), and thus we can express \(\alpha_{ij}\) with EPG.

\[e_{ij} = \frac{2^n - 1}{2^n} (1 - \alpha_{ij}) = \frac{1 - \alpha_{ij}}{2},\]

for the single qubit channel \(n=1\). Accordingly,

\[\alpha_i^{N_1/2} = \prod_{j} (1 - 2 e_{ij})^{n_{ij}},\]

as a composition of depolarization from every primitive gates per qubit. This correction will give you two EPC values as a result of the two-qubit RB experiment. The corrected EPC must be closer to the outcome of interleaved RB. The EPGs of two-qubit RB are analyzed with the corrected EPC if available.

lengths_2_qubit = np.arange(1, 200, 30)
lengths_1_qubit = np.arange(1, 800, 200)
num_samples = 10
seed = 1010
qubits = (1, 2)

# Run a 1-qubit RB experiment on qubits 1, 2 to determine the error-per-gate of 1-qubit gates
single_exps = BatchExperiment(
    [
        StandardRB((qubit,), lengths_1_qubit, num_samples=num_samples, seed=seed)
        for qubit in qubits
    ]
)
expdata_1q = single_exps.run(backend).block_for_results()

# Run an RB experiment on qubits 1, 2
exp_2q = StandardRB(qubits, lengths_2_qubit, num_samples=num_samples, seed=seed)

# Use the EPG data of the 1-qubit runs to ensure correct 2-qubit EPG computation
exp_2q.analysis.set_options(epg_1_qubit=expdata_1q.analysis_results())

# Run the 2-qubit experiment
expdata_2q = exp_2q.run(backend).block_for_results()

# View result data
print("Gate error ratio: %s" % expdata_2q.experiment.analysis.options.gate_error_ratio)
display(expdata_2q.figure(0))
for result in expdata_2q.analysis_results():
    print(result)

Gate error ratio: {'cx': 1.0}

AnalysisResult
- name: @Parameters_RBAnalysis
- value: CurveFitResult:
 - fitting method: least_squares
 - number of sub-models: 1
  * F_rb_decay(x) = a * alpha ** x + b
 - success: True
 - number of function evals: 24
 - degree of freedom: 4
 - chi-square: 2.087904822789605
 - reduced chi-square: 0.5219762056974012
 - Akaike info crit.: -2.468243441203178
 - Bayesian info crit.: -2.6305129940372387
 - init params:
  * a = 0.6889737017106478
  * alpha = 0.9738769536342785
  * b = 0.25
 - fit params:
  * a = 0.6868561029128621 ± 0.0059185079094644585
  * alpha = 0.9761318731130031 ± 0.0006869085720302482
  * b = 0.24996853910296998 ± 0.004219940320079996
 - correlations:
  * (alpha, b) = -0.8092340419648919
  * (a, b) = -0.568307607710408
  * (a, alpha) = 0.29395462628208585
- quality: good
- extra: <2 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: alpha
- value: 0.9761+/-0.0007
- χ²: 0.5219762056974012
- quality: good
- extra: <2 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: EPC
- value: 0.0179+/-0.0005
- χ²: 0.5219762056974012
- quality: good
- extra: <2 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: EPC_corrected
- value: 0.0166+/-0.0007
- χ²: 0.5219762056974012
- quality: good
- extra: <2 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: EPG_cx
- value: 0.0118+/-0.0005
- χ²: 0.5219762056974012
- quality: good
- extra: <2 items>
- device_components: ['Q1', 'Q2']
- verified: False

Note that EPC_corrected value is smaller than one of raw EPC, which indicates contribution of depolarization from single-qubit error channels. If you don’t need EPG value, you can skip its computation by exp_2q.analysis.set_options(gate_error_ratio=False).

Displaying the RB circuits

The default RB circuit output shows Clifford blocks:

# Run an RB experiment on qubit 0
exp = StandardRB(physical_qubits=(0,), lengths=[2], num_samples=1, seed=seed)
c = exp.circuits()[0]
c.draw(output="mpl", style="iqp")

You can decompose the circuit into underlying gates:

c.decompose().draw(output="mpl", style="iqp")

And see the transpiled circuit using the basis gate set of the backend:

from qiskit import transpile
transpile(c, backend, **vars(exp.transpile_options)).draw(output="mpl", style="iqp", idle_wires=False)

Note

In 0.5.0, the default value of optimization_level in transpile_options changed from 0 to 1 for RB experiments. Transpiled circuits may have less number of gates after the change.

Interleaved RB experiment

The interleaved RB experiment is used to estimate the gate error of the interleaved gate (see [4]). In addition to the usual RB parameters, we also need to provide:

• interleaved_element: the element to interleave, given either as a group element or as an instruction/circuit

The analysis results of the RB Experiment includes the following:

• EPC: The estimated error of the interleaved gate

• alpha and alpha_c: The depolarizing parameters of the original and interleaved RB sequences respectively

Extra analysis results include

• EPC_systematic_err: The systematic error of the interleaved gate error [4]

• EPC_systematic_bounds: The systematic error bounds of the interleaved gate error [4]

Let’s run an interleaved RB experiment on two qubits:

lengths = np.arange(1, 200, 30)
num_samples = 10
seed = 1010
qubits = (1, 2)

# The interleaved gate is the CX gate
int_exp2 = InterleavedRB(
    circuits.CXGate(), qubits, lengths, num_samples=num_samples, seed=seed)

int_expdata2 = int_exp2.run(backend).block_for_results()
int_results2 = int_expdata2.analysis_results()

# View result data
display(int_expdata2.figure(0))
for result in int_results2:
    print(result)

AnalysisResult
- name: @Parameters_InterleavedRBAnalysis
- value: CurveFitResult:
 - fitting method: least_squares
 - number of sub-models: 2
  * F_standard(x) = a * alpha ** x + b
  * F_interleaved(x) = a * (alpha_c * alpha) ** x + b
 - success: True
 - number of function evals: 30
 - degree of freedom: 10
 - chi-square: 14.001615418335316
 - reduced chi-square: 1.4001615418335316
 - Akaike info crit.: 8.001615325143328
 - Bayesian info crit.: 10.557844643604362
 - init params:
  * a = 0.6924373527552417
  * alpha = 0.9681756654256702
  * b = 0.25
  * alpha_c = 0.9966005938704241
 - fit params:
  * a = 0.6921557280631909 ± 0.003763141296861875
  * alpha = 0.9762069575311644 ± 0.00051358047081478
  * b = 0.2481260993480654 ± 0.0022209561101203578
  * alpha_c = 0.9854986644432246 ± 0.0008073906016802224
 - correlations:
  * (alpha, b) = -0.5639330186535595
  * (a, b) = -0.4858966317769481
  * (alpha, alpha_c) = -0.2866631669830012
  * (b, alpha_c) = -0.19903151101126276
  * (a, alpha_c) = 0.04994526218105105
  * (a, alpha) = 0.09188803812232266
- quality: good
- extra: <4 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: alpha
- value: 0.9762+/-0.0005
- χ²: 1.4001615418335316
- quality: good
- extra: <4 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: alpha_c
- value: 0.9855+/-0.0008
- χ²: 1.4001615418335316
- quality: good
- extra: <4 items>
- device_components: ['Q1', 'Q2']
- verified: False
AnalysisResult
- name: EPC
- value: 0.0109+/-0.0006
- χ²: 1.4001615418335316
- quality: good
- extra: <4 items>
- device_components: ['Q1', 'Q2']
- verified: False

References

[1]

Easwar Magesan, J. M. Gambetta, and Joseph Emerson, Robust randomized benchmarking of quantum processes, https://arxiv.org/abs/1009.3639.

[2]

Easwar Magesan, Jay M. Gambetta, and Joseph Emerson, Characterizing Quantum Gates via Randomized Benchmarking, https://arxiv.org/abs/1109.6887.

[3] (1,2)

David C. McKay, Sarah Sheldon, John A. Smolin, Jerry M. Chow, and Jay M. Gambetta, Three Qubit Randomized Benchmarking, https://arxiv.org/abs/1712.06550.

[4] (1,2,3)

Easwar Magesan, Jay M. Gambetta, B. R. Johnson, Colm A. Ryan, Jerry M. Chow, Seth T. Merkel, Marcus P. da Silva, George A. Keefe, Mary B. Rothwell, Thomas A. Ohki, Mark B. Ketchen, M. Steffen, Efficient measurement of quantum gate error by interleaved randomized benchmarking, https://arxiv.org/abs/1203.4550.

See also

• API documentation: randomized_benchmarking

• Qiskit Textbook: Randomized Benchmarking