iqm-benchmarks 2.32__py3-none-any.whl → 2.34__py3-none-any.whl

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -2,16 +2,14 @@
 Mirror Randomized Benchmarking.
 """
 
-from copy import deepcopy
-import random
 from time import strftime
-from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, cast
+from typing import Any, Dict, List, Literal, Optional, Sequence, Tuple, Type
 import warnings
 
 import numpy as np
 from qiskit import transpile
 from qiskit.quantum_info import Clifford, random_clifford, random_pauli
-from qiskit_aer import Aer, AerSimulator
+from qiskit_aer import AerSimulator
 from scipy.spatial.distance import hamming
 import xarray as xr
 
@@ -26,11 +24,11 @@ from iqm.benchmarks.benchmark_definition import Benchmark, add_counts_to_dataset
 from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
+    edge_grab,
     exponential_rb,
     fit_decay_lmfit,
     lmfit_minimizer,
     plot_rb_decay,
-    validate_irb_gate,
 )
 from iqm.benchmarks.utils import (
     get_iqm_backend,
@@ -93,143 +91,6 @@ def compute_polarizations(
     return polarizations
 
 
-# TODO: Let edge_grab also admit a 1Q gate ensemble! Currently uniform Clifford by default # pylint: disable=fixme
-# pylint: disable=too-many-branches
-def edge_grab(
-    qubit_set: List[int],
-    n_layers: int,
-    backend_arg: IQMBackendBase | str,
-    density_2q_gates: float = 0.25,
-    two_qubit_gate_ensemble: Optional[Dict[str, float]] = None,
-) -> List[QuantumCircuit]:
-    """Generate a list of random layers containing single-qubit Cliffords and two-qubit gates,
-    sampled according to the edge-grab algorithm (see arXiv:2204.07568 [quant-ph]).
-
-    Args:
-        qubit_set (List[int]): The set of qubits of the backend.
-        n_layers (int): The number of layers.
-        backend_arg (IQMBackendBase | str): IQM backend.
-        density_2q_gates (float): The expected density of 2Q gates in a circuit formed by subsequent application of layers
-        two_qubit_gate_ensemble (Dict[str, float]): A dictionary with keys being str specifying 2Q gates, and values being corresponding probabilities
-    Raises:
-        ValueError: if the probabilities in the gate ensembles do not add up to unity.
-    Returns:
-        List[QuantumCircuit]: the list of gate layers, in the form of quantum circuits.
-    """
-    # Check the ensemble of 2Q gates, otherwise assign
-    if two_qubit_gate_ensemble is None:
-        two_qubit_gate_ensemble = cast(Dict[str, float], {"CZGate": 1.0})
-    elif sum(two_qubit_gate_ensemble.values()) != 1.0:
-        raise ValueError("The 2Q gate ensemble probabilities must sum to 1.0")
-
-    # Validate 2Q gates and get circuits
-    two_qubit_circuits = {}
-    for k in two_qubit_gate_ensemble.keys():
-        two_qubit_circuits[k] = validate_irb_gate(k, backend_arg, gate_params=None)
-    # TODO: Admit parametrized 2Q gates! # pylint: disable=fixme
-
-    # Check backend and retrieve if necessary
-    if isinstance(backend_arg, str):
-        backend = get_iqm_backend(backend_arg)
-    else:
-        backend = backend_arg
-
-    # Definitions
-    num_qubits = len(qubit_set)
-    physical_to_virtual_map = {q: i for i, q in enumerate(qubit_set)}
-
-    # Get the possible edges where to place 2Q gates given the backend connectivity
-    twoq_edges = []
-    for i, q0 in enumerate(qubit_set):
-        for q1 in qubit_set[i + 1 :]:
-            if (q0, q1) in list(backend.coupling_map):
-                twoq_edges.append([q0, q1])
-    twoq_edges = list(sorted(twoq_edges))
-
-    # Generate the layers
-    layer_list = []
-    for _ in range(n_layers):
-        # Pick edges at random and store them in a new list "edge_list"
-        aux = deepcopy(twoq_edges)
-        edge_list = []
-        layer = QuantumCircuit(num_qubits)
-        # Take (and remove) edges from "aux", then add to "edge_list"
-        edge_qubits = []
-        while aux:
-            new_edge = random.choice(aux)
-            edge_list.append(new_edge)
-            edge_qubits = list(np.array(edge_list).flatten())
-            # Removes all edges which include either of the qubits in new_edge
-            aux = [e for e in aux if ((new_edge[0] not in e) and (new_edge[1] not in e))]
-
-        # Define the probability for adding 2Q gates, given the input density
-        if len(edge_list) != 0:
-            prob_2qgate = num_qubits * density_2q_gates / len(edge_list)
-        else:
-            prob_2qgate = 0
-
-        # Add gates in selected edges
-        for e in edge_list:
-            # Sample the 2Q gate
-            two_qubit_gate = random.choices(
-                list(two_qubit_gate_ensemble.keys()),
-                weights=list(two_qubit_gate_ensemble.values()),
-                k=1,
-            )[0]
-
-            # Pick whether to place the sampled 2Q gate according to the probability above
-            is_gate_placed = random.choices(
-                [True, False],
-                weights=[prob_2qgate, 1 - prob_2qgate],
-                k=1,
-            )[0]
-
-            if is_gate_placed:
-                if two_qubit_gate == "clifford":
-                    layer.compose(
-                        random_clifford(2).to_instruction(),
-                        qubits=[
-                            physical_to_virtual_map[e[0]],
-                            physical_to_virtual_map[e[1]],
-                        ],
-                        inplace=True,
-                    )
-                else:
-                    layer.append(
-                        two_qubit_circuits[two_qubit_gate],
-                        [
-                            physical_to_virtual_map[e[0]],
-                            physical_to_virtual_map[e[1]],
-                        ],
-                    )
-            else:
-                layer.compose(
-                    random_clifford(1).to_instruction(),
-                    qubits=[physical_to_virtual_map[e[0]]],
-                    inplace=True,
-                )
-                layer.compose(
-                    random_clifford(1).to_instruction(),
-                    qubits=[physical_to_virtual_map[e[1]]],
-                    inplace=True,
-                )
-
-        # Add 1Q gates in remaining qubits
-        remaining_qubits = [q for q in qubit_set if q not in edge_qubits]
-        while remaining_qubits:
-            for q in remaining_qubits:
-                layer.compose(
-                    random_clifford(1).to_instruction(),
-                    qubits=[physical_to_virtual_map[q]],
-                    inplace=True,
-                )
-                remaining_qubits.remove(q)
-
-        layer_list.append(layer)
-
-    return layer_list
-
-
 def generate_pauli_dressed_mrb_circuits(
     qubits: List[int],
     pauli_samples_per_circ: int,
@@ -237,8 +98,13 @@ def generate_pauli_dressed_mrb_circuits(
     backend_arg: IQMBackendBase | str,
     density_2q_gates: float = 0.25,
     two_qubit_gate_ensemble: Optional[Dict[str, float]] = None,
+    clifford_sqg_probability=1.0,
+    sqg_gate_ensemble: Optional[Dict[str, float]] = None,
     qiskit_optim_level: int = 1,
     routing_method: str = "basic",
+    simulation_method: Literal[
+        "automatic", "statevector", "stabilizer", "extended_stabilizer", "matrix_product_state"
+    ] = "automatic",
 ) -> Dict[str, List[QuantumCircuit]]:
     """Samples a mirror circuit and generates samples of "Pauli-dressed" circuits,
         where for each circuit, random Pauli layers are interleaved between each layer of the circuit
@@ -249,16 +115,34 @@ def generate_pauli_dressed_mrb_circuits(
         depth (int): the depth (number of canonical layers) of the circuit
         backend_arg (IQMBackendBase | str): the backend
         density_2q_gates (float): the expected density of 2Q gates
-        two_qubit_gate_ensemble (Optional[Dict[str, float]]):
-        qiskit_optim_level (int):
-        routing_method (str):
+        two_qubit_gate_ensemble (Optional[Dict[str, float]]): A dictionary with keys being str specifying 2Q gates, and values being corresponding probabilities.
+                * Default is None.
+        clifford_sqg_probability (float): Probability with which to uniformly sample Clifford 1Q gates.
+                * Default is 1.0.
+        sqg_gate_ensemble (Optional[Dict[str, float]]): A dictionary with keys being str specifying 1Q gates, and values being corresponding probabilities.
+                * Default is None.
+        qiskit_optim_level (int): Qiskit transpiler optimization level.
+                * Default is 1.
+        routing_method (str): Qiskit transpiler routing method.
+                * Default is "basic".
+        simulation_method (Literal["automatic", "statevector", "stabilizer", "extended_stabilizer", "matrix_product_state"]):
+                Qiskit's Aer simulation method
+                * Default is "automatic".
     Returns:
-
+        Dict[str, List[QuantumCircuit]]
     """
     num_qubits = len(qubits)
 
     # Sample the layers using edge grab sampler - different samplers may be conditionally chosen here in the future
-    cycle_layers = edge_grab(qubits, depth, backend_arg, density_2q_gates, two_qubit_gate_ensemble)
+    cycle_layers = edge_grab(
+        qubits,
+        depth,
+        backend_arg,
+        density_2q_gates,
+        two_qubit_gate_ensemble,
+        clifford_sqg_probability,
+        sqg_gate_ensemble,
+    )
 
     # Sample the edge (initial/final) random Single-qubit Clifford layer
     clifford_layer = [random_clifford(1) for _ in range(num_qubits)]
@@ -268,13 +152,11 @@ def generate_pauli_dressed_mrb_circuits(
     pauli_dressed_circuits_untranspiled: List[QuantumCircuit] = []
     pauli_dressed_circuits_transpiled: List[QuantumCircuit] = []
 
-    sim_method = "stabilizer"
-    simulator = AerSimulator(method=sim_method)
+    simulator = AerSimulator(method=simulation_method)
 
     for _ in range(pauli_samples_per_circ):
         # Initialize the quantum circuit object
         circ = QuantumCircuit(num_qubits)
-        circ_untransp = QuantumCircuit(num_qubits)
         # Sample all the random Paulis
         paulis = [random_pauli(num_qubits) for _ in range(depth + 1)]
 
@@ -292,7 +174,6 @@ def generate_pauli_dressed_mrb_circuits(
             )
             circ.barrier()
             circ.compose(cycle_layers[k], inplace=True)
-            circ_untransp.compose(cycle_layers[k], inplace=True)
             circ.barrier()
 
         # Apply middle Pauli
@@ -369,8 +250,13 @@ def generate_fixed_depth_mrb_circuits(
     backend_arg: IQMBackendBase | str,
     density_2q_gates: float = 0.25,
     two_qubit_gate_ensemble: Optional[Dict[str, float]] = None,
+    clifford_sqg_probability=1.0,
+    sqg_gate_ensemble: Optional[Dict[str, float]] = None,
     qiskit_optim_level: int = 1,
     routing_method: str = "basic",
+    simulation_method: Literal[
+        "automatic", "statevector", "stabilizer", "extended_stabilizer", "matrix_product_state"
+    ] = "automatic",
 ) -> Dict[int, Dict[str, List[QuantumCircuit]]]:
     """Generates a dictionary MRB circuits at fixed depth, indexed by sample number
 
@@ -380,10 +266,21 @@ def generate_fixed_depth_mrb_circuits(
         pauli_samples_per_circ (int): the number of pauli samples per circuit
         depth (int): the depth (number of canonical layers) of the circuits
         backend_arg (IQMBackendBase | str): the backend
-        density_2q_gates (float):
+        density_2q_gates (float): the expected density of 2Q gates
+        two_qubit_gate_ensemble (Optional[Dict[str, float]]): A dictionary with keys being str specifying 2Q gates, and values being corresponding probabilities.
+                * Default is None.
         two_qubit_gate_ensemble (Optional[Dict[str, float]]):
-        qiskit_optim_level (int):
-        routing_method (str):
+        clifford_sqg_probability (float): Probability with which to uniformly sample Clifford 1Q gates.
+                * Default is 1.0.
+        sqg_gate_ensemble (Optional[Dict[str, float]]): A dictionary with keys being str specifying 1Q gates, and values being corresponding probabilities.
+                * Default is None.
+        qiskit_optim_level (int): Qiskit transpiler optimization level.
+                * Default is 1.
+        routing_method (str): Qiskit transpiler routing method.
+                * Default is "basic".
+        simulation_method (Literal["automatic", "statevector", "stabilizer", "extended_stabilizer", "matrix_product_state"]):
+                            Qiskit's Aer simulation method
+                            * Default is "automatic".
     Returns:
         A dictionary of lists of Pauli-dressed quantum circuits corresponding to the circuit sample index
     """
@@ -397,8 +294,11 @@ def generate_fixed_depth_mrb_circuits(
             backend_arg,
             density_2q_gates,
             two_qubit_gate_ensemble,
-            qiskit_optim_level,
-            routing_method,
+            clifford_sqg_probability,
+            sqg_gate_ensemble,
+            qiskit_optim_level=qiskit_optim_level,
+            routing_method=routing_method,
+            simulation_method=simulation_method,
         )
 
     return circuits
@@ -532,7 +432,7 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
                 "polarizations": polarizations,
                 "average_polarization_nominal_values": average_polarizations,
-                "average_polatization_stderr": stddevs_from_mean,
+                "average_polarization_stderr": stddevs_from_mean,
                 "fitting_method": str(rb_fit_results.method),
                 "num_function_evals": int(rb_fit_results.nfev),
                 "data_points": int(rb_fit_results.ndata),
@@ -606,18 +506,26 @@ class MirrorRandomizedBenchmarking(Benchmark):
 
         self.qubits_array = configuration.qubits_array
         self.depths_array = configuration.depths_array
+
         self.num_circuit_samples = configuration.num_circuit_samples
         self.num_pauli_samples = configuration.num_pauli_samples
+
         self.two_qubit_gate_ensemble = configuration.two_qubit_gate_ensemble
         self.density_2q_gates = configuration.density_2q_gates
+        self.clifford_sqg_probability = configuration.clifford_sqg_probability
+        self.sqg_gate_ensemble = configuration.sqg_gate_ensemble
 
         self.qiskit_optim_level = configuration.qiskit_optim_level
 
-        self.simulator = Aer.get_backend("qasm_simulator")
+        self.simulation_method = configuration.simulation_method
 
         self.session_timestamp = strftime("%Y%m%d-%H%M%S")
         self.execution_timestamp = ""
 
+        # Initialize the variable to contain the circuits for each layout
+        self.untranspiled_circuits = BenchmarkCircuit("untranspiled_circuits")
+        self.transpiled_circuits = BenchmarkCircuit("transpiled_circuits")
+
     def add_all_meta_to_dataset(self, dataset: xr.Dataset):
         """Adds all configuration metadata and circuits to the dataset variable
 
@@ -685,10 +593,6 @@ class MirrorRandomizedBenchmarking(Benchmark):
         all_mrb_jobs: List[Dict[str, Any]] = []
         time_circuit_generation: Dict[str, float] = {}
 
-        # Initialize the variable to contain the circuits for each layout
-        self.untranspiled_circuits = BenchmarkCircuit("untranspiled_circuits")
-        self.transpiled_circuits = BenchmarkCircuit("transpiled_circuits")
-
         # The depths should be assigned to each set of qubits!
         # The real final MRB depths are twice the originally specified, must be taken into account here!
         assigned_mrb_depths = {}
@@ -731,8 +635,11 @@ class MirrorRandomizedBenchmarking(Benchmark):
                     backend,
                     self.density_2q_gates,
                     self.two_qubit_gate_ensemble,
+                    self.clifford_sqg_probability,
+                    self.sqg_gate_ensemble,
                     self.qiskit_optim_level,
                     self.routing_method,
+                    self.simulation_method,
                 )
                 time_circuit_generation[str(qubits)] += elapsed_time
 
@@ -759,7 +666,6 @@ class MirrorRandomizedBenchmarking(Benchmark):
             dataset.attrs[qubits_idx] = {"qubits": qubits}
 
         # Retrieve counts of jobs for all qubit layouts
-        all_job_metadata = {}
         for job_dict in all_mrb_jobs:
             qubits = job_dict["qubits"]
             depth = job_dict["depth"]
@@ -813,6 +719,13 @@ class MirrorRBConfiguration(BenchmarkConfigurationBase):
                             * Default is {"CZGate": 1.0}.
         density_2q_gates (float): The expected density of 2-qubit gates in the final circuits.
                             * Default is 0.25.
+        clifford_sqg_probability (float): Probability with which to uniformly sample Clifford 1Q gates.
+                * Default is 1.0.
+        sqg_gate_ensemble (Optional[Dict[str, float]]): A dictionary with keys being str specifying 1Q gates, and values being corresponding probabilities.
+                * Default is None.
+        simulation_method (Literal["automatic", "statevector", "stabilizer", "extended_stabilizer", "matrix_product_state"]):
+                            Qiskit's Aer simulation method
+                            * Default is "automatic".
     """
 
     benchmark: Type[Benchmark] = MirrorRandomizedBenchmarking
@@ -825,3 +738,8 @@ class MirrorRBConfiguration(BenchmarkConfigurationBase):
         "CZGate": 1.0,
     }
     density_2q_gates: float = 0.25
+    clifford_sqg_probability: float = 1.0
+    sqg_gate_ensemble: Optional[Dict[str, float]] = None
+    simulation_method: Literal[
+        "automatic", "statevector", "stabilizer", "extended_stabilizer", "matrix_product_state"
+    ] = "automatic"