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.

LayerFidelityUnitary¶

class LayerFidelityUnitary(physical_qubits, two_qubit_layers, lengths, two_qubit_gates, num_samples=6, backend=None, seed=None, two_qubit_basis_gates=None, one_qubit_basis_gates=None, layer_barrier=True, min_delay=None)[source]¶

A holistic benchmarking experiment to characterize the full quality of the devices at scale.

Overview

Unitary Layer Fidelity (ULF) is a method to estimate the fidelity of a connecting set of arbitrary two-qubit gates over \(N\) qubits by measuring gate errors using simultaneous direct unitary randomized benchmarking (RB) in disjoint layers. LF can easily be expressed as a layer size independent quantity, error per layered gate (EPLG): \(EPLG = 1 - LF^{1/N_{2Q}}\) where \(N_{2Q}\) is number of 2-qubit gates in the layers.

Each of the 2-qubit (or 1-qubit) direct RBs yields the decaying probabilities to get back to the ground state for an increasing sequence length (i.e. number of layers), fits the exponential curve to estimate the decay rate, and calculates the process fidelity of the subsystem from the rate. LF is calculated as the product of the 2-qubit (or 1-qubit) process fidelities. See Ref. [1] for details.

This unitary version allows artibrary 2Q gates

References

[1] David C. McKay, Ian Hincks, Emily J. Pritchett, Malcolm Carroll, Luke C. G. Govia, Seth T. Merkel, Benchmarking Quantum Processor Performance at Scale (open)

Analysis class reference

LayerFidelityAnalysis

Experiment options

These options can be set by the set_experiment_options() method.

Options

Defined in the class LayerFidelityUnitary:
- two_qubit_layers (List[List[Tuple[int, int]]])
  
  Default value: None
  
  List of two-qubit gate layers to run on. Each two-qubit gate layer must be given as a list of directed qubit pairs.
- lengths (List[int])
  
  Default value: None
  
  A list of layer lengths.
- num_samples (int)
  
  Default value: None
  
  Number of samples to generate for each layer length.
- seed (None or int or SeedSequence or BitGenerator or Generator)
  
  Default value: None
  
  A seed used to initialize numpy.random.default_rng when generating circuits. The default_rng will be initialized with this seed value every time circuits() is called.
- two_qubit_gates (list of gates or circuit instructions)
  
  Default value: None
  
  Two qubit circuits
- two_qubit_basis_gates (Tuple[str])
  
  Default value: None
  
  Two-qubit gates to use for implementing inverse.
- one_qubit_basis_gates (Tuple[str])
  
  Default value: None
  
  One-qubit gates to use for implementing 1q Cliffords.
- clifford_synthesis_method (str)
  
  Default value: "rb_default"
  
  The name of the Clifford synthesis plugin to use for building circuits of RB sequences. See Synthesis Methods.
- layer_barrier (bool)
  
  Default value: True
  
  Optional, enforce a barrier across the whole layer. Default is True, which is the defined protocol for layer fidelity. If this is set to false the code runs simultaneous direct 1+2Q RB without a barrier across all qubits.
- min_delay (List[int])
  
  Default value: None
  
  Optional. Define a minimum delay in each 2Q layer in units of dt. This delay operation will be applied in any 1Q edge of the layer during the 2Q gate layer in order to enforce a minimum duration of the 2Q layer. This enables some crosstalk testing by removing a gate from the layer without changing the layer duration. If not None then is a list equal in length to the number of two_qubit_layers. Note that this options requires at least one 1Q edge (a qubit in physical_qubits but not in two_qubit_layers) to be applied. Also will not have an impact on the 2Q gates if layer_barrier=False.
Defined in the class BaseExperiment:
- max_circuits (Optional[int])
  
  Default value: None
  
  The maximum number of circuits per job when running an experiment on a backend.

Example

import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import RZZGate
from qiskit_experiments.library.randomized_benchmarking import LayerFidelityUnitary

lengths = np.arange(1, 80, 10)
two_qubit_layers=[[(0, 1), (3, 5)], [(1, 3), (5, 6)]]

num_samples = 3
seed = 106

# Can load this way if benchmarking a generic circuit
# qc = QuantumCircuit(2)
# qc.rzz(0.5,0,1)
# two_qubit_gates=[qc.to_instruction()]

exp = LayerFidelityUnitary(
        physical_qubits=[0, 1, 3, 5, 6],
        two_qubit_layers=two_qubit_layers,
        lengths=lengths,
        backend=backend,
        num_samples=num_samples,
        seed=seed,
        two_qubit_gates=[RZZGate(0.5)],
)

exp_data = exp.run().block_for_results()
results = exp_data.analysis_results(dataframe=True)

display(exp_data.figure(0)) # one of 6 figures
display(exp_data.analysis_results("EPLG", dataframe=True))

print(f"Available results: {set(results.name)}")

../_images/qiskit_experiments.library.randomized_benchmarking.LayerFidelityUnitary_1_0.png

	name	experiment	components	value	quality	backend	run_time	qubits	reason	a	alpha	b	chisq
e0cd068e	EPLG	LayerFidelityUnitary	[Q0, Q1, Q3, Q5, Q6]	0.0622+/-0.0009	bad	aer_simulator	None	None	None	None	None	None	None

Available results: {'LF', 'EPL', 'EPLG', 'SingleLF', 'alpha', 'ProcessFidelity'}

Initialization

Initialize a unitary layer fidelity experiment.

Parameters:

physical_qubits (Sequence[int]) – List of physical qubits for the experiment.
two_qubit_layers (Sequence[Sequence[Tuple[int, int]]]) – List of two-qubit gate layers to run on. Each two-qubit gate layer must be given as a list of directed qubit pairs.
lengths (Iterable[int]) – A list of layer lengths (the number of depth points).
two_qubit_gates (Sequence[Instruction | Gate]) – A list of two qubit circuit instructions or gates that will be in the entangling layer. If more than one than they are sampled from this list. These are assumed to be the backend ISA already.
num_samples (int) – Number of samples (i.e. circuits) to generate for each layer length.
backend (Backend | None) – Optional, the backend to run the experiment on. Note that either backend or two_qubit_gate and one_qubit_basis_gates must be set at instantiation.
seed (int | SeedSequence | BitGenerator | Generator | None) – Optional, seed used to initialize numpy.random.default_rng. when generating circuits. The default_rng will be initialized with this seed value every time :meth:~.LayerFidelity.circuits` is called.
two_qubit_basis_gates (Sequence[str] | None) – Optional, 2q-gates to use for transpiling the inverse. If not specified (but backend is supplied), all 2q-gates supported in the backend are automatically set.
one_qubit_basis_gates (Sequence[str] | None) – Optional, 1q-gates to use for implementing 1q-Clifford operations. If not specified (but backend is supplied), all 1q-gates supported in the backend are automatically set.
layer_barrier (bool) – Optional, enforce a barrier across the whole layer. Default is True, which is the defined protocol for layer fidelity. If this is set to false the code runs simultaneous direct 1+2Q RB without a barrier across all qubits.
min_delay (Sequence[int] | None) – Optional. Define a minimum delay in each 2Q layer in units of dt. This delay operation will be applied in any 1Q edge of the layer during the 2Q gate layer in order to enforce a minimum duration of the 2Q layer. This enables some crosstalk testing by removing a gate from the layer without changing the layer duration. If not None then is a list equal in length to the number of two_qubit_layers. Note that this options requires at least one 1Q edge (a qubit in physical_qubits but not in two_qubit_layers) to be applied. Also will not have an impact on the 2Q gates if layer_barrier=False.

Raises:

QiskitError – If any invalid argument is supplied.

Attributes

analysis¶: Return the analysis instance for the experiment

backend¶: Return the backend for the experiment

experiment_options¶: Return the options for the experiment.

experiment_type¶: Return experiment type.

num_qubits¶: Return the number of qubits for the experiment.

physical_qubits¶: Return the device qubits for the experiment.

run_options¶: Return options values for the experiment run() method.

transpile_options¶: Return the transpiler options for the run() method.

Methods

circuits()[source]¶

Return a list of physical circuits to measure layer fidelity.

Returns:: A list of QuantumCircuits.
Return type:: List[QuantumCircuit]

circuits_generator()[source]¶

Return a generator of physical circuits to measure layer fidelity.

Returns:: A generator of QuantumCircuits.
Return type:: Iterable[QuantumCircuit]

config()¶

Return the config dataclass for this experiment

Return type:: ExperimentConfig

copy()¶

Return a copy of the experiment

Return type:: BaseExperiment

classmethod from_config(config)[source]¶

Initialize an experiment from experiment config

Return type:: LayerFidelity

job_info(backend=None)¶

Get information about job distribution for the experiment on a specific backend.

Parameters:

backend (Backend) – Optional, the backend for which to get job distribution information. If not specified, the experiment must already have a set backend.

Returns:

A dictionary containing information about job distribution.

”Total number of circuits in the experiment”: Total number of circuits in the experiment.

”Maximum number of circuits per job”: Maximum number of circuits in one job based on backend and experiment settings.

”Total number of jobs”: Number of jobs needed to run this experiment on the currently set backend.

Return type:

dict

Raises:

QiskitError – if backend is not specified.

run(backend=None, sampler=None, analysis='default', timeout=None, backend_run=None, **run_options)¶

Run an experiment and perform analysis.

Parameters:

backend (Backend | None) – Optional, the backend to run on. Will override existing backend settings.
sampler (BaseSamplerV2 | None) – Optional, the sampler to run the experiment on. If None then a sampler will be invoked from previously set backend
analysis (BaseAnalysis | None) – Optional, a custom analysis instance to use for performing analysis. If None analysis will not be run. If "default" the experiments analysis() instance will be used if it contains one.
timeout (float | None) – Time to wait for experiment jobs to finish running before cancelling.
backend_run (bool | None) – Use backend run (temp option for testing)
run_options – backend runtime options used for circuit execution.

Returns:

The experiment data object.

Raises:

QiskitError – If experiment is run with an incompatible existing ExperimentData container.

Return type:

ExperimentData

set_experiment_options(**fields)[source]¶

Set the experiment options.

Parameters:: fields – The fields to update the options
Raises:: AttributeError – If the field passed in is not a supported options

set_run_options(**fields)¶

Set options values for the experiment run() method.

Parameters:: fields – The fields to update the options