iqm-benchmarks 2.31__py3-none-any.whl → 2.33__py3-none-any.whl

iqm/benchmarks/utils.py

@@ -20,12 +20,14 @@ from functools import wraps
 import itertools
 from math import floor
 import os
+import random
 from time import time
 from typing import Any, Dict, Iterable, List, Literal, Optional, Sequence, Set, Tuple, Union, cast
 import warnings
 
 from more_itertools import chunked
 from mthree.utils import final_measurement_mapping
+import networkx as nx
 import numpy as np
 from numpy.random import Generator
 from qiskit import ClassicalRegister, transpile
@@ -47,12 +49,12 @@ from iqm.qiskit_iqm.iqm_provider import IQMProvider
 
 
 def timeit(f):
-    """Calculates the amount of time a function takes to execute
+    """Calculates the amount of time a function takes to execute.
 
     Args:
-        f: The function to add the timing attribute to
+        f: The function to add the timing attribute to.
     Returns:
-        The decorated function execution with logger statement of elapsed time in execution
+        The decorated function execution with logger statement of elapsed time in execution.
     """
 
     @wraps(f)
@@ -168,7 +170,7 @@ def count_native_gates(
 
     native_operations = backend.operation_names
 
-    if "move" in backend.architecture.gates:
+    if backend.has_resonators():
         native_operations.append("move")
     # Some backends may not include "barrier" in the operation_names attribute
     if "barrier" not in native_operations:
@@ -281,6 +283,50 @@ def get_active_qubits(qc: QuantumCircuit) -> List[int]:
     return list(active_qubits)
 
 
+def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]:
+    """Returns couplings and CZ-fidelities from calibration data URL
+
+    Args:
+        cal_url: str
+            The url under which the calibration data for the backend can be found
+    Returns:
+        list_couplings: List[List[int]]
+            A list of pairs, each of which is a qubit coupling for which the calibration
+            data contains a fidelity.
+        list_fids: List[float]
+            A list of CZ fidelities from the calibration url, ordered in the same way as list_couplings
+        topology: str
+            Name of the chip topology layout, currently either "star" or "crystal"
+    """
+    headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
+    r = requests.get(cal_url, headers=headers, timeout=60)
+    calibration = r.json()
+    cal_keys = {
+        el2["key"]: (i, j) for i, el1 in enumerate(calibration["calibrations"]) for j, el2 in enumerate(el1["metrics"])
+    }
+    list_couplings = []
+    list_fids = []
+    if "double_move_gate_fidelity" in cal_keys.keys():
+        i, j = cal_keys["double_move_gate_fidelity"]
+        topology = "star"
+    else:
+        i, j = cal_keys["cz_gate_fidelity"]
+        topology = "crystal"
+    for item in calibration["calibrations"][i]["metrics"][j]["metrics"]:
+        qb1 = int(item["locus"][0][2:]) if item["locus"][0] != "COMP_R" else 0
+        qb2 = int(item["locus"][1][2:]) if item["locus"][1] != "COMP_R" else 0
+        if topology == "star":
+            list_couplings.append([qb1, qb2])
+        else:
+            list_couplings.append([qb1 - 1, qb2 - 1])
+        list_fids.append(float(item["value"]))
+    calibrated_qubits = set(np.array(list_couplings).reshape(-1))
+    qubit_mapping = {qubit: idx for idx, qubit in enumerate(calibrated_qubits)}
+    list_couplings = [[qubit_mapping[edge[0]], qubit_mapping[edge[1]]] for edge in list_couplings]
+
+    return list_couplings, list_fids, topology
+
+
 # pylint: disable=too-many-branches
 def get_iqm_backend(backend_label: str) -> IQMBackendBase:
     """Get the IQM backend object from a backend name (str).
@@ -320,8 +366,20 @@ def get_iqm_backend(backend_label: str) -> IQMBackendBase:
     elif backend_label.lower() in ("iqmfakedeneb", "fakedeneb"):
         backend_object = IQMFakeDeneb()
 
+    # ****** 16Q Resonator Star ******
+    # Sirius
+    elif backend_label.lower() == "sirius":
+        iqm_server_url = "https://cocos.resonance.meetiqm.com/sirius"
+        provider = IQMProvider(iqm_server_url)
+        backend_object = provider.get_backend()
+    # FakeSirius
+    # elif backend_label.lower() in ("iqmfakesirius", "fakesirius"):
+    #     backend_object = IQMFakeSirius()
+
     else:
-        raise ValueError(f"Backend {backend_label} not supported. Try 'garnet', 'deneb', 'fakeadonis' or 'fakeapollo'.")
+        raise ValueError(
+            f"Backend {backend_label} not supported. Try 'garnet', 'deneb', 'sirius', 'fakeadonis' or 'fakeapollo'."
+        )
 
     return backend_object
 
@@ -517,12 +575,12 @@ def perform_backend_transpilation(
             initial_layout=qubits if aux_qc is None else None,
             routing_method=routing_method,
         )
-        if "move" in backend.architecture.gates:
+        if backend.has_resonators():
             transpiled = transpile_to_IQM(
                 qc, backend=backend, optimize_single_qubits=optimize_sqg, remove_final_rzs=drop_final_rz
             )
         if aux_qc is not None:
-            if "move" in backend.architecture.gates:
+            if backend.has_resonators():
                 if backend.num_qubits in qubits:
                     raise ValueError(
                         f"Label {backend.num_qubits} is reserved for Resonator - "
@@ -546,7 +604,7 @@ def perform_backend_transpilation(
     if coupling_map == backend.coupling_map:
         transpiled_qc_list = [transpile_and_optimize(qc) for qc in qc_list]
     else:  # The coupling map will be reduced if the physical layout is to be fixed
-        if "move" in backend.architecture.gates:
+        if backend.has_resonators():
             aux_qc_list = [QuantumCircuit(backend.num_qubits + 1, q.num_clbits) for q in qc_list]
         else:
             aux_qc_list = [QuantumCircuit(backend.num_qubits, q.num_clbits) for q in qc_list]
@@ -555,6 +613,47 @@ def perform_backend_transpilation(
     return transpiled_qc_list
 
 
+def random_hamiltonian_path(G: nx.Graph, N: int) -> List[Tuple[int, int]]:
+    """
+    Generates a random Hamiltonian path with N vertices from a given NetworkX graph.
+
+    Args:
+        G (networkx.Graph): The input graph.
+        N (int): The desired number of vertices in the Hamiltonian path.
+
+    Returns:
+        list: A list of edges (tuples of nodes) representing the Hamiltonian path, or an empty list if not possible.
+    """
+    if N > len(G):
+        raise ValueError(
+            f"The number of vertices in the Hamiltonian path ({N}) cannot be greater than the number of nodes in the graph ({len(G)})"
+        )
+
+    nodes = list(G.nodes)
+    random.shuffle(nodes)  # Shuffle nodes to introduce randomness
+
+    for start in nodes:
+        path = [start]
+        visited = set(path)
+        edges = []
+
+        while len(path) < N:
+            neighbors = [n for n in G.neighbors(path[-1]) if n not in visited]
+
+            if not neighbors:
+                break  # Dead end, stop trying this path
+
+            next_node = random.choice(neighbors)
+            edges.append((int(path[-1]), int(next_node)))
+            path.append(next_node)
+            visited.add(next_node)
+
+        if len(path) == N:
+            return edges  # Successfully found a Hamiltonian path of length N
+
+    return []  # No valid path found
+
+
 def reduce_to_active_qubits(
     circuit: QuantumCircuit, backend_topology: Optional[str] = None, backend_num_qubits=None
 ) -> QuantumCircuit:
@@ -725,6 +824,34 @@ def split_sequence_in_chunks(sequence_in: Sequence[Any], split_size: int) -> Lis
     return [sequence_in[i : i + split_size] for i in range(0, len(sequence_in), split_size)]
 
 
+def split_into_disjoint_pairs(pairs: Sequence[Tuple[int, int]]) -> List[List[Tuple[int, int]]]:
+    """
+    Split a Sequence of pairs of integers into a List of a minimal number of Lists of disjoint pairs.
+    Example: input [(0,3), (2,3), (3,8), (8,13), (13,17), (17,18)] gives
+    output [[(0, 3), (8, 13), (17, 18)], [(2, 3), (13, 17)], [(3, 8)]].
+
+    # TODO: enable specifying a max split size of Lists of disjoint pairs. # pylint: disable=fixme
+
+    Args:
+        pairs (Sequence[Tuple[int, int]]): The input list of pairs of integers.
+    Returns:
+        List[List[Tuple[int, int]]]: A List of Lists of disjoint pairs.
+    """
+    result: List[List[Tuple[int, int]]] = []
+
+    for pair in pairs:
+        added = False
+        for group in result:
+            if not any(elem in pair for p in group for elem in p):
+                group.append(pair)
+                added = True
+                break
+        if not added:
+            result.append([pair])
+
+    return result
+
+
 @timeit
 def sort_batches_by_final_layout(
     transpiled_circuit_list: List[QuantumCircuit],
@@ -824,7 +951,9 @@ def submit_execute(
                 qcvv_logger.warning(
                     "Both max_gates_per_batch and max_circuits_per_batch are not None. Selecting the one giving the smallest batches."
                 )
-                batching_size = min(max_circuits_per_batch, max(1, floor(max_gates_per_batch / avg_gates_per_qc)))  # type: ignore
+                batching_size = min(
+                    cast(int, max_circuits_per_batch), max(1, floor(cast(int, max_gates_per_batch) / avg_gates_per_qc))
+                )
                 if batching_size == max_circuits_per_batch:
                     restriction = "max_circuits_per_batch"
                 else:
@@ -861,47 +990,3 @@ def xrvariable_to_counts(dataset: xr.Dataset, identifier: str, counts_range: int
         dict(zip(list(dataset[f"{identifier}_state_{u}"].data), dataset[f"{identifier}_counts_{u}"].data))
         for u in range(counts_range)
     ]
-
-
-def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]:
-    """Returns couplings and CZ-fidelities from calibration data URL
-
-    Args:
-        cal_url: str
-            The url under which the calibration data for the backend can be found
-    Returns:
-        list_couplings: List[List[int]]
-            A list of pairs, each of which is a qubit coupling for which the calibration
-            data contains a fidelity.
-        list_fids: List[float]
-            A list of CZ fidelities from the calibration url, ordered in the same way as list_couplings
-        topology: str
-            Name of the chip topology layout, currently either "star" or "crystal"
-    """
-    headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
-    r = requests.get(cal_url, headers=headers, timeout=60)
-    calibration = r.json()
-    cal_keys = {
-        el2["key"]: (i, j) for i, el1 in enumerate(calibration["calibrations"]) for j, el2 in enumerate(el1["metrics"])
-    }
-    list_couplings = []
-    list_fids = []
-    if "double_move_gate_fidelity" in cal_keys.keys():
-        i, j = cal_keys["double_move_gate_fidelity"]
-        topology = "star"
-    else:
-        i, j = cal_keys["cz_gate_fidelity"]
-        topology = "crystal"
-    for item in calibration["calibrations"][i]["metrics"][j]["metrics"]:
-        qb1 = int(item["locus"][0][2:]) if "COMP" not in item["locus"][0] else 0
-        qb2 = int(item["locus"][1][2:]) if "COMP" not in item["locus"][1] else 0
-        list_couplings.append([qb1 - 1, qb2 - 1])
-        list_fids.append(float(item["value"]))
-    calibrated_qubits = set(np.array(list_couplings).reshape(-1))
-    qubit_mapping = {}
-    if topology == "star":
-        qubit_mapping.update({-1: len(calibrated_qubits)})  # Place resonator qubit as last qubit
-    qubit_mapping.update({qubit: idx for idx, qubit in enumerate(calibrated_qubits)})
-    list_couplings = [[qubit_mapping[edge[0]], qubit_mapping[edge[1]]] for edge in list_couplings]
-
-    return list_couplings, list_fids, topology

iqm/benchmarks/utils_plots.py

@@ -16,15 +16,20 @@
 Plotting and visualization utility functions
 """
 from dataclasses import dataclass
-from typing import Dict, Literal, Optional, Tuple
+import os
+from typing import Dict, List, Literal, Optional, Sequence, Tuple
 
+from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
 from qiskit.transpiler import CouplingMap
+import requests
 from rustworkx import PyGraph, spring_layout, visualization  # pylint: disable=no-name-in-module
 
-from iqm.benchmarks.utils import extract_fidelities
+from iqm.benchmarks.logging_config import qcvv_logger
+from iqm.benchmarks.utils import extract_fidelities, get_iqm_backend, random_hamiltonian_path
+from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
 @dataclass
@@ -73,7 +78,14 @@ class GraphPositions:
         6: (3.0, 3.0),
     }
 
-    predefined_stations = {"garnet": garnet_positions, "deneb": deneb_positions}
+    predefined_stations = {
+        "garnet": garnet_positions,
+        "fakeapollo": garnet_positions,
+        "iqmfakeapollo": garnet_positions,
+        "deneb": deneb_positions,
+        "fakedeneb": deneb_positions,
+        "iqmfakedeneb": deneb_positions,
+    }
 
     @staticmethod
     def create_positions(
@@ -117,6 +129,179 @@ class GraphPositions:
         return pos
 
 
+def draw_graph_edges(
+    backend_coupling_map: CouplingMap,
+    backend_num_qubits: int,
+    edge_list: Sequence[Tuple[int, int]],
+    timestamp: str,
+    disjoint_layers: Optional[Sequence[Sequence[Tuple[int, int]]]] = None,
+    station: Optional[str] = None,
+    qubit_names: Optional[Dict[int, str]] = None,
+    is_eplg: Optional[bool] = False,
+) -> Tuple[str, Figure]:
+    """Draw given edges on a graph within the given backend.
+
+    Args:
+        backend_coupling_map (CouplingMap): The coupling map to draw the graph from.
+        backend_num_qubits (int): The number of qubits of the respectve backend.
+        edge_list (Sequence[Tuple[int, int]]): The edge list of the linear chain.
+        timestamp (str): The timestamp to include in the figure name.
+        disjoint_layers (Optional[Sequence[Sequence[Tuple[int, int]]]): Sequences of edges defining disjoint layers to draw.
+            * Default is None.
+        station (Optional[str]): The name of the station.
+            * Default is None.
+        qubit_names (Optional[Dict[int, str]]): A dictionary mapping qubit indices to their names.
+            * Default is None.
+        is_eplg (Optional[bool]): A flag indicating if the graph refers to an EPLG experiment.
+            * Default is False.
+
+    Returns:
+         Tuple[str, Figure]: The figure name and the figure object.
+    """
+    disjoint = "_disjoint" if disjoint_layers is not None else ""
+    fig_name_station = f"_{station.lower()}" if station is not None else ""
+    fig_name = f"edges_graph{disjoint}{fig_name_station}_{timestamp}"
+
+    fig = plt.figure()
+    ax = plt.axes()
+
+    if station is not None:
+        if station.lower() in GraphPositions.predefined_stations:
+            qubit_positions = GraphPositions.predefined_stations[station.lower()]
+        else:
+            if backend_num_qubits in (6, 20):
+                station = "garnet" if backend_num_qubits == 20 else "deneb"
+                qubit_positions = GraphPositions.predefined_stations[station]
+            else:
+                graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
+                qubit_positions = GraphPositions.create_positions(graph_backend)
+    else:
+        graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
+        if backend_num_qubits in (6, 20):
+            station = "garnet" if backend_num_qubits == 20 else "deneb"
+            qubit_positions = GraphPositions.predefined_stations[station]
+        else:
+            qubit_positions = GraphPositions.create_positions(graph_backend)
+
+    label_station = station if station is not None else f"{backend_num_qubits}-qubit IQM Backend"
+    if disjoint_layers is None:
+        nx.draw_networkx(
+            rx_to_nx_graph(backend_coupling_map),
+            pos=qubit_positions,
+            edgelist=edge_list,
+            width=4.0,
+            edge_color="k",
+            node_color="k",
+            font_color="w",
+            ax=ax,
+        )
+
+        plt.title(f"Selected edges in {label_station}\n" f"\n{timestamp}")
+
+    else:
+        num_disjoint_layers = len(disjoint_layers)
+        colors = plt.colormaps["rainbow"](np.linspace(0, 1, num_disjoint_layers))
+        all_edge_colors = [[colors[i]] * len(l) for i, l in enumerate(disjoint_layers)]  # Flatten below
+        nx.draw_networkx(
+            rx_to_nx_graph(backend_coupling_map),
+            pos=qubit_positions,
+            labels=(
+                {x: qubit_names[x] for x in range(backend_num_qubits)}
+                if qubit_names
+                else list(range(backend_num_qubits))
+            ),
+            font_size=6.5 if qubit_names else 10,
+            edgelist=[x for y in disjoint_layers for x in y],
+            width=4.0,
+            edge_color=[x for y in all_edge_colors for x in y],
+            node_color="k",
+            font_color="w",
+            ax=ax,
+        )
+
+        is_eplg_string = " for EPLG experiment" if is_eplg else ""
+        plt.title(
+            f"Selected edges in {label_station.capitalize()}{is_eplg_string}\n"
+            f"{len(disjoint_layers)} groups of disjoint layers"
+            f"\n{timestamp}"
+        )
+    ax.set_aspect(0.925)
+    plt.close()
+
+    return fig_name, fig
+
+
+def evaluate_hamiltonian_paths(
+    N: int,
+    path_samples: int,
+    backend_arg: str | IQMBackendBase,
+    url: str,
+    max_tries: int = 10,
+) -> Dict[int, List[Tuple[int, int]]]:
+    """Evaluates Hamiltonian paths according to the product of 2Q gate fidelities on the corresponding edges of the backend graph.
+
+    Args:
+        N (int): the number of vertices in the Hamiltonian paths to evaluate.
+        path_samples (int): the number of Hamiltonian paths to evaluate.
+        backend_arg (str | IQMBackendBase): the backend to evaluate the Hamiltonian paths on with respect to fidelity.
+        url (str): the URL address for the backend to retrieve calibration data from.
+        max_tries (int): the maximum number of tries to generate a Hamiltonian path.
+
+    Returns:
+        Dict[int, List[Tuple[int, int]]]: A dictionary with keys being fidelity products and values being the respective Hamiltonian paths.
+    """
+    if isinstance(backend_arg, str):
+        backend = get_iqm_backend(backend_arg)
+    else:
+        backend = backend_arg
+
+    backend_nx_graph = rx_to_nx_graph(backend.coupling_map)
+
+    all_paths = []
+    sample_counter = 0
+    tries = 0
+    while sample_counter < path_samples and tries <= max_tries:
+        h_path = random_hamiltonian_path(backend_nx_graph, N)
+        if not h_path:
+            qcvv_logger.debug(f"Failed to generate a Hamiltonian path with {N} vertices - retrying...")
+            tries += 1
+            if tries == max_tries:
+                raise RecursionError(
+                    f"Max tries to generate a Hamiltonian path with {N} vertices reached - Try with less vertices!\n"
+                    f"For EPLG, you may also manually specify qubit pairs."
+                )
+            continue
+        all_paths.append(h_path)
+        tries = 0
+        sample_counter += 1
+
+    # Get scores for all paths
+    # Retrieve fidelity data
+    two_qubit_fidelity = {}
+
+    headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
+    r = requests.get(url, headers=headers, timeout=60)
+    calibration = r.json()
+
+    for iq in calibration["calibrations"][0]["metrics"][0]["metrics"]:
+        temp = list(iq.values())
+        two_qubit_fidelity[str(temp[0])] = temp[1]
+        two_qubit_fidelity[str([temp[0][1], temp[0][0]])] = temp[1]
+
+    # Rate all the paths
+    path_costs = {}  # keys are costs, values are edge paths
+    for h_path in all_paths:
+        total_cost = 1
+        for edge in h_path:
+            if len(edge) == 2:
+                total_cost *= two_qubit_fidelity[
+                    str([backend.index_to_qubit_name(edge[0]), backend.index_to_qubit_name(edge[1])])
+                ]
+        path_costs[total_cost] = h_path
+
+    return path_costs
+
+
 def plot_layout_fidelity_graph(
     cal_url: str, qubit_layouts: Optional[list[list[int]]] = None, station: Optional[str] = None
 ):
@@ -162,21 +347,7 @@ def plot_layout_fidelity_graph(
         for qb in {qb for layout in qubit_layouts for qb in layout}:
             node_colors[qb] = "orange"
 
-    # Ensuring weights are in correct order for the plot
-    edge_list = graph.edge_list()
-    weights_dict = {}
-    edge_pos = set()
-
-    # Create a mapping between edge positions as defined in rustworkx and their weights
-    for e, w in zip(edge_list, weights):
-        pos_tuple = (tuple(pos[e[0]]), tuple(pos[e[1]]))
-        weights_dict[pos_tuple] = w
-        edge_pos.add(pos_tuple)
-
-    # Get corresponding weights in the same order
-    weights_ordered = np.array([weights_dict[edge] for edge in list(edge_pos)])
-
-    plt.subplots(figsize=(6, 6))
+    plt.subplots(figsize=(1.5 * np.sqrt(len(nodes)), 1.5 * np.sqrt(len(nodes))))
 
     # Draw the graph
     visualization.mpl_draw(
@@ -185,7 +356,7 @@ def plot_layout_fidelity_graph(
         node_color=node_colors,
         pos=pos,
         labels=lambda node: node,
-        width=7 * weights_ordered / np.max(weights_ordered),
+        width=7 * weights / np.max(weights),
     )  # type: ignore[call-arg]
 
     # Add edge labels using matplotlib's annotate
@@ -222,6 +393,7 @@ def rx_to_nx_graph(backend_coupling_map: CouplingMap) -> nx.Graph:
         networkx.Graph: The Networkx Graph corresponding to the backend graph.
 
     """
+
     # Generate a Networkx graph
     graph_backend = backend_coupling_map.graph.to_undirected(multigraph=False)
     backend_egdes, backend_nodes = (list(graph_backend.edge_list()), list(graph_backend.node_indices()))

{iqm_benchmarks-2.31.dist-info → iqm_benchmarks-2.33.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.31
+Version: 2.33
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -21,6 +21,7 @@ Requires-Dist: numpy<2.0,>=1.25.2
 Requires-Dist: qiskit<2.0,>=1.2.4
 Requires-Dist: qiskit-iqm<18.0,>=17.8
 Requires-Dist: iqm-client>=22.7
+Requires-Dist: requests<3.0,>=2.32.3
 Requires-Dist: scikit-optimize<0.11.0,>=0.10.2
 Requires-Dist: tabulate<1.0.0,>=0.9.0
 Requires-Dist: uncertainties<3.3.0,>=3.2.2
@@ -64,6 +65,7 @@ Below is a list of the benchmarks currently available in the suite:
   - Interleaved Randomized Benchmarking [[Phys. Rev. Lett. 109, 080505](https://doi.org/10.1103/PhysRevLett.109.080505) (2012)]
   - Compressive Gate Set Tomography [[PRX Quantum 4, 010325](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.4.010325) (2023)]
   - Mirror Randomized Benchmarking [[Phys. Rev. Lett. 129, 150502](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.129.150502) (2022)]
+  - Error Per Layered Gate [[arXiv:2311.05933 [quant-ph]](https://arxiv.org/abs/2311.05933) (2023)]
 * Holistic:
   - Quantum Volume [[Phys. Rev. A 100, 032328](https://doi.org/10.1103/PhysRevA.100.032328) (2019)]
   - CLOPS [[arXiv:2110.14108 [quant-ph]](https://arxiv.org/abs/2110.14108) (2021)]

{iqm_benchmarks-2.31.dist-info → iqm_benchmarks-2.33.dist-info}/RECORD

@@ -1,18 +1,18 @@
-iqm/benchmarks/__init__.py,sha256=74NuBycITM-CV7nx0l1T2wbnQDdVmF8jTZVE0KpG7pc,2773
+iqm/benchmarks/__init__.py,sha256=-drZ_whue067Tu4I9RxBCqrrzu38Tm5Kqf9jHTftUPk,3070
 iqm/benchmarks/benchmark.py,sha256=3E7g7RQjCIGIpSI1gOSrI3V9SAVs-XEOMrPgToK_7vw,4972
 iqm/benchmarks/benchmark_definition.py,sha256=e4xe0wlWKZqj48_6-zTglMaMeoiA9aGkHrrSgoCfPkM,11271
 iqm/benchmarks/circuit_containers.py,sha256=anEtZEsodYqOX-34oZRmuKGeEpp_VfgG5045Mz4-4hI,7562
 iqm/benchmarks/logging_config.py,sha256=U7olP5Kr75AcLJqNODf9VBhJLVqIvA4AYR6J39D5rww,1052
 iqm/benchmarks/readout_mitigation.py,sha256=Q2SOGWTNgmklOYkNxepAaSaXlxSj0QQyymYY1bOkT8A,11756
-iqm/benchmarks/utils.py,sha256=2aEwFhZAHBmqLjSMtnqjuWcXCyMX3vpUfF-vqoeBIHw,38517
-iqm/benchmarks/utils_plots.py,sha256=gNeGf5bnZjvKGGSglCFLonbG3oOd_z30mCx66__cbEY,8035
+iqm/benchmarks/utils.py,sha256=HywFLNDq713HYebtQfKpzP_cXXD9DbyPGdxArsukQbw,41233
+iqm/benchmarks/utils_plots.py,sha256=Q4h7gcKXf8Eizm13P0yL2I_P-QobHVFr9JCV83wrUi8,14942
 iqm/benchmarks/utils_shadows.py,sha256=e77PV_uaAO5m_woox9lAzompKAvFeDJ-0AKJrNJ7NFg,9728
 iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
 iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=2kiRttog4jR-vtMHu847GTFe5qL_i_uYr_4WMGqt9Ww,25653
-iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=y4Yk9v1N9DP91MieXTMIASzjoFlg2pCzkm4LhvEYi0k,36335
+iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=g0kEovWbetoDRvX7JFrS9oOoNrqBxaFmprujJi7qQbU,36297
 iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
 iqm/benchmarks/entanglement/ghz.py,sha256=RGA6ynJFsfaCJv0nKccsiIzPk2G-iHHvIeW8LVu30HY,41249
-iqm/benchmarks/entanglement/graph_states.py,sha256=7IlPocwHbi_K_KQqTSVEaDfB7wLH9loTawqDnnaDYek,62528
+iqm/benchmarks/entanglement/graph_states.py,sha256=qv6nAgbvm1toSgNGLjBA8DpF9fN7UUlMpPeR_gixMcI,62561
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
 iqm/benchmarks/optimization/qscore.py,sha256=KOw8fjXeMwCjYvKukpX7IiAqRQrVTkrnIgKjNCPVWdw,38130
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
@@ -22,14 +22,18 @@ iqm/benchmarks/randomized_benchmarking/__init__.py,sha256=IkKo-7zUChxZZd3my_csQC
 iqm/benchmarks/randomized_benchmarking/clifford_1q.pkl,sha256=yrmSJqhv7Lb1yqiqU9-2baqTljJPNmTUPQR-AH6GGfc,7800
 iqm/benchmarks/randomized_benchmarking/clifford_2q.pkl,sha256=mJQLubWPOb-DbmFi4oKYJqAMW_Yyo3eJjRjLGl9Sqmo,10282247
 iqm/benchmarks/randomized_benchmarking/multi_lmfit.py,sha256=Se1ygR4mXn_2_P82Ch31KBnCmY-g_A9NKzE9Ir8nEvw,3247
-iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=MryufwrOCBcZZHDeX9WGHVtYhFz2XtS3xLm6YQYEAM4,43160
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=kX4ODF7MEB5olYKjpnUVon0hJ0irTOxz-z1exCa7mqc,54286
 iqm/benchmarks/randomized_benchmarking/clifford_rb/__init__.py,sha256=bTDA156LAl7OLGcMec--1nzDrV1XpPRVq3CquTmucgE,677
 iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=IGBrq_a9eaVPknkBLKHKS4BOcumHn6TZdasUNKTZjGI,18685
+iqm/benchmarks/randomized_benchmarking/direct_rb/__init__.py,sha256=lCIIeWMFZHnMUUEUTjUBvrhhUur6uBTHIVkxFBSfHC4,681
+iqm/benchmarks/randomized_benchmarking/direct_rb/direct_rb.py,sha256=Cbx6B9q8Sqc_uPalX6fUEWJX6UEHCfWRof9u4brtx5A,48977
+iqm/benchmarks/randomized_benchmarking/eplg/__init__.py,sha256=1MeGZTErElXJypQV2rQf7hwqLLvIp_JNVbwNhaP5vyI,696
+iqm/benchmarks/randomized_benchmarking/eplg/eplg.py,sha256=VifpRgw8AHHu1NG9N86lcF0lFhFtauQUaclk5mc__EY,17217
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=TaR1YFWBhOgm1hmEQzuwLYpp0yl0Xpuo3jAT6YhiXpc,28471
-iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=ZekEqI_89nXzGO1vjM-b5Uwwicy59M4fYHXfA-f0MIg,674
-iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=_xdp8XLPcZyuqy7Xz8-K8H7zjgRo9ZxFiDgCXE72gaE,34997
-iqm_benchmarks-2.31.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=jRKbivWCZ3xdO1k0sx-ygC3s5DUkGSModd975PoAtcg,692
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=n_5gt9636ZDMsM9hC3Zm5qP2bQr2sy41zxGhOh0XMjI,32932
+iqm_benchmarks-2.33.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
@@ -40,7 +44,7 @@ mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
 mGST/qiskit_interface.py,sha256=ajx6Zn5FnrX_T7tMP8xnBLyG4c2ddFRm0Fu2_3r1t30,10118
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
 mGST/reporting/reporting.py,sha256=B8NWfpZrrSmyH7lwZxd0EbZMYLsAGK1YsHRB4D5qXH4,26002
-iqm_benchmarks-2.31.dist-info/METADATA,sha256=q-6NOPnr9dvN0ZQ1clPFZ4nFhgd38se5bR8tC_MxsdA,10710
-iqm_benchmarks-2.31.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-iqm_benchmarks-2.31.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.31.dist-info/RECORD,,
+iqm_benchmarks-2.33.dist-info/METADATA,sha256=XMUhEH8xorvgfxDPTRpjgp7hVd9bfZnsFgzTcxOhLI4,10847
+iqm_benchmarks-2.33.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+iqm_benchmarks-2.33.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.33.dist-info/RECORD,,