iqm-benchmarks 2.43__py3-none-any.whl → 2.45__py3-none-any.whl

iqm/benchmarks/utils_plots.py

@@ -17,9 +17,10 @@ Plotting and visualization utility functions
 """
 from dataclasses import dataclass
 import os
-from typing import Dict, List, Literal, Optional, Sequence, Tuple
+from typing import Dict, List, Literal, Optional, Sequence, Tuple, cast
 
 from matplotlib.figure import Figure
+from matplotlib.patches import Circle, FancyBboxPatch
 import matplotlib.pyplot as plt
 import networkx as nx
 import numpy as np
@@ -40,9 +41,9 @@ class GraphPositions:
     provides methods to generate positions for different layout types.
 
     Attributes:
-        garnet_positions (Dict[int, Tuple[int, int]]): Mapping of node indices to (x,y) positions for Garnet chip.
-        deneb_positions (Dict[int, Tuple[int, int]]): Mapping of node indices to (x,y) positions for Deneb chip.
-        predefined_stations (Dict[str, Dict[int, Tuple[int, int]]]): Mapping of chip names to their position dictionaries.
+        garnet_positions (Dict[int, Tuple[float, float]]): Mapping of node indices to (x,y) positions for Garnet chip.
+        deneb_positions (Dict[int, Tuple[float, float]]): Mapping of node indices to (x,y) positions for Deneb chip.
+        predefined_stations (Dict[str, Dict[int, Tuple[float, float]]]): Mapping of chip names to their position dictionaries.
     """
 
     garnet_positions = {
@@ -68,15 +69,116 @@ class GraphPositions:
         19: (3.0, 1.0),
     }
 
+    emerald_positions = {
+        0: (10, 10),
+        1: (11, 9),
+        2: (7, 11),
+        3: (8, 10),
+        4: (9, 9),
+        5: (10, 8),
+        6: (11, 7),
+        7: (5, 11),
+        8: (6, 10),
+        9: (7, 9),
+        10: (8, 8),
+        11: (9, 7),
+        12: (10, 6),
+        13: (11, 5),
+        14: (3, 11),
+        15: (4, 10),
+        16: (5, 9),
+        17: (6, 8),
+        18: (7, 7),
+        19: (8, 6),
+        20: (9, 5),
+        21: (10, 4),
+        22: (2, 10),
+        23: (3, 9),
+        24: (4, 8),
+        25: (5, 7),
+        26: (6, 6),
+        27: (7, 5),
+        28: (8, 4),
+        29: (9, 3),
+        30: (10, 2),
+        31: (2, 8),
+        32: (3, 7),
+        33: (4, 6),
+        34: (5, 5),
+        35: (6, 4),
+        36: (7, 3),
+        37: (8, 2),
+        38: (9, 1),
+        39: (1, 7),
+        40: (2, 6),
+        41: (3, 5),
+        42: (4, 4),
+        43: (5, 3),
+        44: (6, 2),
+        45: (7, 1),
+        46: (1, 5),
+        47: (2, 4),
+        48: (3, 3),
+        49: (4, 2),
+        50: (5, 1),
+        51: (1, 3),
+        52: (2, 2),
+        53: (3, 1),
+    }
+
+    sirius_positions = {
+        # Even nodes on the bottom
+        2: (1, 5),
+        4: (3, 5),
+        6: (5, 5),
+        8: (7, 5),
+        10: (9, 5),
+        12: (11, 5),
+        14: (13, 5),
+        16: (15, 5),
+        18: (17, 5),
+        20: (19, 5),
+        22: (21, 5),
+        24: (23, 5),
+        # Odd nodes on the top
+        1: (1, 1),
+        3: (3, 1),
+        5: (5, 1),
+        7: (7, 1),
+        9: (9, 1),
+        11: (11, 1),
+        13: (13, 1),
+        15: (15, 1),
+        17: (17, 1),
+        19: (19, 1),
+        21: (21, 1),
+        23: (23, 1),
+    }
+    # Add dummy indices for the resonator
+    max_qubit_number = np.max(list(sirius_positions.keys()))
+    previous_nodes = list(sirius_positions.keys())
+    for node in previous_nodes:
+        sirius_positions.update({node + max_qubit_number: (sirius_positions[node][0], 3)})
+    # Node 0 in the middle
+    sirius_positions.update({0: (16.5, 3)})
+
     deneb_positions = {
-        0: (2.0, 2.0),
-        1: (1.0, 1.0),
-        3: (2.0, 1.0),
-        5: (3.0, 1.0),
-        2: (1.0, 3.0),
-        4: (2.0, 3.0),
-        6: (3.0, 3.0),
+        # Even nodes on the bottom
+        2: (1, 5),
+        4: (3, 5),
+        6: (5, 5),
+        # Odd nodes on the top
+        1: (1, 1),
+        3: (3, 1),
+        5: (5, 1),
     }
+    # Add dummy indices for the resonator
+    max_qubit_number = np.max(list(deneb_positions.keys()))
+    previous_nodes = list(deneb_positions.keys())
+    for node in previous_nodes:
+        deneb_positions.update({node + max_qubit_number: (deneb_positions[node][0], 3)})
+    # Node 0 in the middle
+    deneb_positions.update({0: (2.5, 3)})
 
     predefined_stations = {
         "garnet": garnet_positions,
@@ -85,6 +187,8 @@ class GraphPositions:
         "deneb": deneb_positions,
         "fakedeneb": deneb_positions,
         "iqmfakedeneb": deneb_positions,
+        "emerald": emerald_positions,
+        "sirius": sirius_positions,
     }
 
     @staticmethod
@@ -128,6 +232,40 @@ class GraphPositions:
             }
         return pos
 
+    @staticmethod
+    def get_positions(
+        station: Optional[str] = None, graph: Optional[PyGraph] = None, num_qubits: Optional[int] = None
+    ) -> Dict[int, Tuple[float, float]]:
+        """Get predefined positions for a specific station or generate positions for a custom graph.
+
+        Args:
+            station (Optional[str]): The name of the station to get predefined positions for.
+                If None, positions will be generated algorithmically.
+            graph (Optional[PyGraph]): The graph to generate positions for if no predefined positions exist.
+                Used only when station is None and num_qubits doesn't match any predefined layout.
+            num_qubits (Optional[int]): The number of qubits to get a layout for.
+                If matches a known system, predefined positions will be used.
+
+        Returns:
+            Dict[int, Tuple[float, float]]: A dictionary mapping node indices to (x,y) coordinates.
+
+        Raises:
+            ValueError: If none of station, graph, or num_qubits are provided, or if num_qubits doesn't
+                match any predefined layout and graph is None.
+        """
+        if station is not None and station.lower() in GraphPositions.predefined_stations:
+            qubit_positions = cast(Dict[int, Tuple[float, float]], GraphPositions.predefined_stations[station.lower()])
+        else:
+            qubit_station_dict = {6: "deneb", 7: "deneb", 20: "garnet", 24: "sirius", 17: "sirius", 54: "emerald"}
+            if num_qubits is not None and num_qubits in qubit_station_dict:
+                station = qubit_station_dict[num_qubits]
+                qubit_positions = cast(Dict[int, Tuple[float, float]], GraphPositions.predefined_stations[station])
+            elif graph is not None:
+                qubit_positions = GraphPositions.create_positions(graph)
+            else:
+                raise ValueError("Either a station name, a graph, or a qubit count must be provided to get positions.")
+        return qubit_positions
+
 
 def draw_graph_edges(
     backend_coupling_map: CouplingMap,
@@ -165,23 +303,7 @@ def draw_graph_edges(
     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)
+    qubit_positions = GraphPositions.get_positions(station=station, graph=None, num_qubits=backend_num_qubits)
 
     label_station = station if station is not None else f"{backend_num_qubits}-qubit IQM Backend"
     if disjoint_layers is None:
@@ -226,6 +348,7 @@ def draw_graph_edges(
             f"\n{timestamp}"
         )
     ax.set_aspect(0.925)
+    plt.gca().invert_yaxis()
     plt.close()
 
     return fig_name, fig
@@ -302,8 +425,55 @@ def evaluate_hamiltonian_paths(
     return path_costs
 
 
+def calculate_node_radii(metric_dict: Dict[str, Dict[int, float]], qubit_nodes: List[int], sq_metric: str) -> np.ndarray:
+    """Calculate node radii based on the specified single qubit metric. For the coherence metric, the fidelity is calculated as the idling fidelity of a single qubit gate duration.
+
+    Args:
+        metric_dict (Dict[str, Dict[int, float]]): Dictionary containing various qubit metrics.
+        qubit_nodes (List[int]): List of qubits to calculate the radius for.
+        sq_metric (str): Metric to use for radius calculation.
+                         Options: "fidelity", "coherence", or "readout".
+
+    Returns:
+        numpy.ndarray: Array of radii values for each qubit node.
+
+    Raises:
+        ValueError: If an unsupported metric type is provided.
+    """
+    if sq_metric == "fidelity":
+        radii = -np.log(np.array([metric_dict["fidelity_1qb_gates_averaged"][node] for node in qubit_nodes]))
+        if "fidelity_1qb_gates_averaged" not in metric_dict:
+            raise ValueError(
+                "The metric 'fidelity_1qb_gates_averaged' is not available in the backend metrics."
+            )
+    elif sq_metric == "coherence":
+        if "t1_time" not in metric_dict or "t2_time" not in metric_dict:
+            raise ValueError(
+                "At least one of the metrics 't1_time' and 't2_time' is not available in the backend metrics."
+            )
+        sqg_time = 32e-9
+        t1_times = [metric_dict["t1_time"][node] for node in qubit_nodes]
+        t2_times = [metric_dict["t2_time"][node] for node in qubit_nodes]
+        idle_fidelities = (3 + np.exp(-sqg_time / np.array(t1_times)) + 2 * np.exp(-sqg_time / np.array(t2_times))) / 6
+        radii = -np.log(idle_fidelities)
+    elif sq_metric == "readout":
+        if "single_shot_readout_fidelity" not in metric_dict:
+            raise ValueError(
+                "The metric 'single_shot_readout_fidelity' is both available in the backend metrics."
+            )
+        readout_fidelities = [metric_dict["single_shot_readout_fidelity"][node] for node in qubit_nodes]
+        radii = -np.log(readout_fidelities)
+    else:
+        raise ValueError(
+            f"Unsupported single qubit metric: {sq_metric}, supported metrics are: fidelity, coherence, readout"
+        )
+    return radii
+
 def plot_layout_fidelity_graph(
-    cal_url: str, qubit_layouts: Optional[list[list[int]]] = None, station: Optional[str] = None
+    cal_url: str,
+    qubit_layouts: Optional[list[list[int]]] = None,
+    station: Optional[str] = None,
+    sq_metric: Optional[str] = "coherence",
 ):
     """Plot a graph showing the quantum chip layout with fidelity information.
 
@@ -316,57 +486,75 @@ def plot_layout_fidelity_graph(
         qubit_layouts: List of qubit layouts where each layout is a list of qubit indices
         station: Name of the quantum computing station to use predefined positions for.
                 If None, positions will be generated algorithmically.
+        sq_metric: Optional single qubit metric to use for the visualization, can be either "fidelity", "coherence",
+                or "readout".
 
     Returns:
         matplotlib.figure.Figure: The generated figure object containing the graph visualization
     """
-    edges_cal, fidelities_cal, topology = extract_fidelities(cal_url)
-    weights = -np.log(np.array(fidelities_cal))
-    edges_graph = [tuple(edge) + (weight,) for edge, weight in zip(edges_cal, weights)]
-
-    graph = PyGraph()
-
-    # Add nodes
-    nodes: set[int] = set()
-    for edge in edges_graph:
-        nodes.update(edge[:2])
-    graph.add_nodes_from(list(nodes))
+    # pylint: disable=unbalanced-tuple-unpacking, disable=too-many-statements
+    edges_cal, fidelities_cal, topology, qubit_mapping, metric_dict = extract_fidelities(cal_url, all_metrics=True)
+    if topology == "star":
+        idx_to_qubit = {idx: qubit for qubit, idx in qubit_mapping.items()}
+        qubit_nodes = list(idx_to_qubit.keys())[1:]
+        fig, ax = plt.subplots(figsize=(len(qubit_nodes), 3))
+    else:
+        # For other topologies, qubits are indexed starting from 0 as per the Qiskit convention
+        idx_to_qubit = {idx: qubit - 1 for qubit, idx in qubit_mapping.items()}
+        qubit_nodes = list(idx_to_qubit.keys())
+        fig, ax = plt.subplots(figsize=(1.5 * np.sqrt(len(qubit_nodes)), 1.5 * np.sqrt(len(qubit_nodes))))
 
-    # Add edges
-    graph.add_edges_from(edges_graph)
+    weights = -np.log(np.array(fidelities_cal))
+    calibrated_nodes = list(idx_to_qubit.keys())
 
     # Define qubit positions in plot
-    if station is not None and station.lower() in GraphPositions.predefined_stations:
-        pos = GraphPositions.predefined_stations[station.lower()]
-    else:
-        pos = GraphPositions.create_positions(graph, topology)
+    qubit_positions = GraphPositions.get_positions(station=station, graph=None, num_qubits=len(calibrated_nodes))
 
-    # Define node colors
-    node_colors = ["lightgrey" for _ in range(len(nodes))]
-    if qubit_layouts is not None:
-        for qb in {qb for layout in qubit_layouts for qb in layout}:
-            node_colors[qb] = "orange"
-
-    plt.subplots(figsize=(1.5 * np.sqrt(len(nodes)), 1.5 * np.sqrt(len(nodes))))
+    graph = PyGraph()
+    nodes = list(set(qubit_positions.keys()))
+    graph.add_nodes_from(nodes)
+    for edge, weight in zip(edges_cal, weights):
+        if topology == "star":
+            max_qubit_number = (np.max(list(qubit_positions.keys())) + 1) // 2
+            graph.add_edge(idx_to_qubit[edge[0]], idx_to_qubit[edge[0]] + max_qubit_number, weight)
+        else:
+            graph.add_edge(idx_to_qubit[edge[0]], idx_to_qubit[edge[1]], weight)
 
-    # Draw the graph
+    # Draw the main graph
     visualization.mpl_draw(
         graph,
+        ax=ax,
         with_labels=True,
-        node_color=node_colors,
-        pos=pos,
+        node_color="none",  # No node color since we're using circles
+        pos=qubit_positions,
         labels=lambda node: node,
-        width=7 * weights / np.max(weights),
+        font_color="white",
+        width=graph.edges() / np.max(graph.edges()) * 10,
     )  # type: ignore[call-arg]
 
+    # Draw nodes as circles with varying radii given by the single qubit metric
+    radii = calculate_node_radii(metric_dict, qubit_nodes, sq_metric)
+    node_colors = ["darkgray" for _ in range(len(nodes))]
+    if qubit_layouts is not None:
+        for qb in {qb for layout in qubit_layouts for qb in layout}:
+            node_colors[qb] = "orange"
+    max_radius = 0.12 + np.max(radii) / np.max(radii) / 2.5
+
+    for idx, node in enumerate(qubit_nodes):
+        position = qubit_positions[idx_to_qubit[node]]
+        radius = 0.12 + radii[idx] / np.max(radii) / 2.5
+        circle = Circle(position, radius=radius, color=node_colors[idx_to_qubit[node]], fill=True, alpha=1)
+        ax.add_patch(circle)
+
     # Add edge labels using matplotlib's annotate
-    for edge in edges_graph:
-        x1, y1 = pos[edge[0]]
-        x2, y2 = pos[edge[1]]
+    # for idx, edge in enumerate(edges_cal):
+    for edge, weight in zip(list(graph.edge_list()), graph.edges()):
+        x1, y1 = qubit_positions[edge[0]]
+        x2, y2 = qubit_positions[edge[1]]
         x = (x1 + x2) / 2
         y = (y1 + y2) / 2
         plt.annotate(
-            f"{edge[2]:.1e}",
+            f"{weight:.1e}",
             xy=(x, y),
             xytext=(0, 0),
             textcoords="offset points",
@@ -375,12 +563,68 @@ def plot_layout_fidelity_graph(
             bbox={"boxstyle": "round,pad=0.2", "fc": "white", "ec": "none", "alpha": 0.6},
         )
 
-    plt.gca().invert_yaxis()
-    plt.title(
-        "Chip layout with selected qubits in orange\n"
-        + "and gate errors indicated by edge thickness (thinner is better)"
+    # Add horizontal bar representing resonator
+    if topology == "star":
+        resonator_height = 3
+        resonator_thickness = 0.8
+        x_min = 0.5
+        x_max = qubit_positions[idx_to_qubit[qubit_nodes[-1]]][0] + 0.5
+        resonator_width = x_max - x_min
+
+        # Create rectangle with rounded corners
+        resonator = FancyBboxPatch(
+            (x_min, resonator_height - resonator_thickness / 2),
+            resonator_width,
+            resonator_thickness,
+            boxstyle="round,pad=0.01,rounding_size=0.3",
+            color="lightsteelblue",
+            zorder=10,
+        )
+        ax.add_patch(resonator)
+
+        # Add "Resonator" label in the center
+        plt.annotate(
+            "Resonator",
+            xy=((x_min + x_max) / 2, resonator_height),
+            xytext=(0, 0),
+            textcoords="offset points",
+            ha="center",
+            va="center",
+            color="black",
+            fontsize=10,
+            zorder=11,
+            bbox={"boxstyle": "round,pad=0.2", "fc": "white", "ec": "none", "alpha": 0.8},
+        )
+
+    # Calculate axis limits to ensure all circles are visible
+    all_x = [pos[0] for pos in qubit_positions.values()]
+    all_y = [pos[1] for pos in qubit_positions.values()]
+    x_min, x_max = min(all_x), max(all_x)
+    y_min, y_max = min(all_y), max(all_y)
+
+    # Add padding for circles
+    padding = max_radius * 1.5
+    ax.set_xlim(x_min - padding, x_max + padding)
+    ax.set_ylim(y_min - padding, y_max + padding)
+
+    # Adjust layout first
+    plt.tight_layout(pad=2.0)
+    ax.set_aspect("equal")
+    ax.invert_yaxis()
+
+    plt.figtext(
+        0.5,
+        0.99,  # x=0.5 (center), y=0.01 (bottom)
+        f"Qubit connectivity with selected qubits in orange\n"
+        f"CZ errors -log(F) indicated by edge thickness (thinner is better)\n"
+        f"Single qubit errors -log(F) shown as node size with F computed from {sq_metric} metrics",
+        fontsize=10,
+        ha="center",
+        wrap=True,
     )
+
     plt.show()
+    return fig
 
 
 def rx_to_nx_graph(backend_coupling_map: CouplingMap) -> nx.Graph:

{iqm_benchmarks-2.43.dist-info → iqm_benchmarks-2.45.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.43
+Version: 2.45
 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
@@ -63,7 +63,7 @@ Below is a list of the benchmarks currently available in the suite:
 * Gates / Layers:
   - Standard Clifford Randomized Benchmarking [[Phys. Rev. A 85, 042311](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.85.042311) (2012)]
   - 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)]
+  - Compressive Gate Set Tomography [[PRX Quantum 4, 010325](https://journals.aps.org/prxquantum/abstract/10.1103/PRXQuantum.4.010325) (2023)] (Optional dependencies required)
   - 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:

{iqm_benchmarks-2.43.dist-info → iqm_benchmarks-2.45.dist-info}/RECORD

@@ -1,24 +1,24 @@
 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/benchmark_definition.py,sha256=7sq9_Y0iu1ZJOjG0gAVpm_BK3hbJBa6bdcRKhcVFOJw,11321
 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=sItoMsfUYiMWTSCNOTe_RWi2l1xTf2slvXkFiEMRwKU,41091
-iqm/benchmarks/utils_plots.py,sha256=Q4h7gcKXf8Eizm13P0yL2I_P-QobHVFr9JCV83wrUi8,14942
+iqm/benchmarks/utils.py,sha256=kJz9T9nJXpLl_iFYYUDtSq83N-Y3JFQBuvW1o7-AVSM,44137
+iqm/benchmarks/utils_plots.py,sha256=CaqA9fJNgRnrbYqwBdpzFUlhwvKw5lhZX3KfRlroQV4,24420
 iqm/benchmarks/utils_shadows.py,sha256=e77PV_uaAO5m_woox9lAzompKAvFeDJ-0AKJrNJ7NFg,9728
 iqm/benchmarks/coherence/__init__.py,sha256=yeyhk-_Lp8IbJ-f5lQj0HP5Q1HSKK_FzuXHazotUrVY,704
 iqm/benchmarks/coherence/coherence.py,sha256=zX_6A8vCS2zeWesMDXPFZBfrJ8wUG90JI9_tFsonwXk,21191
 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=g0kEovWbetoDRvX7JFrS9oOoNrqBxaFmprujJi7qQbU,36297
+iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=c33PUisGlmPUkt4Nx2Xqmduji5qFCrWT9jMcoThcs7U,27992
+iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=H6EQGbpI_sig69Jy6hflg6alMTtjB0t9tHftygzA2YA,41240
 iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
-iqm/benchmarks/entanglement/ghz.py,sha256=12bf9ANfgzyR7Vs8REO-Xm68gisqn8Q7_WSfaNnAmOk,41213
-iqm/benchmarks/entanglement/graph_states.py,sha256=7GMxuhbOeQXc3hn3yAwp51S-F-1qaP0AYXm6JtuL9gA,62560
+iqm/benchmarks/entanglement/ghz.py,sha256=7QI7r9x5VEYQu5kqmdsLV9nq3eedYV_WRVqCQTbjapk,41294
+iqm/benchmarks/entanglement/graph_states.py,sha256=saoAw2QF8j7W4nZMOElnjuNylqDAbY9cBwBypWZKUz8,62521
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=D2BVVNAqO32uGu5_kLVl2XJUOBlRl1C-c6zYenaCBMg,37259
+iqm/benchmarks/optimization/qscore.py,sha256=hh96ZVYU7rUYCBEQyhFZNv0IOQoAwM5RYfRvqRl05ow,37281
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=fLY0aPHjNbW33SuVM9brAgBYFncDHjY5Bwh6iXzbjiU,31099
+iqm/benchmarks/quantum_volume/clops.py,sha256=QS9iK-gtop0zix6IBeUumQeG01-0dXsv0jsYSDhgEu0,31071
 iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=pro7Lz-A5pPpT9UZ8wtXKTyhdWmTjQjRHt4BylDR-3U,36553
 iqm/benchmarks/randomized_benchmarking/__init__.py,sha256=IkKo-7zUChxZZd3my_csQCJfJfZNsV3-JTvdG8uqys4,734
 iqm/benchmarks/randomized_benchmarking/clifford_1q.pkl,sha256=yrmSJqhv7Lb1yqiqU9-2baqTljJPNmTUPQR-AH6GGfc,7800
@@ -30,23 +30,23 @@ iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=IGBrq_a
 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=WZ3OwQ4C3K8SzudILAUwt71lb24vQQO9vaT0C9GCSOc,17215
+iqm/benchmarks/randomized_benchmarking/eplg/eplg.py,sha256=3A_gxzAs6mi3APKvqCwYDcNwRogIZNy5SDL33Cro89E,17036
 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=jRKbivWCZ3xdO1k0sx-ygC3s5DUkGSModd975PoAtcg,692
 iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=n_5gt9636ZDMsM9hC3Zm5qP2bQr2sy41zxGhOh0XMjI,32932
-iqm_benchmarks-2.43.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.45.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
-mGST/algorithm.py,sha256=mXcDG9_0j3hVjxLyc585dsj_yvydfrWNlCrcnUOQHPw,26625
+mGST/additional_fns.py,sha256=MV0Pm5ap59IjhT_E3QhsZyM7lXOF1RZ9SD11zoaf43A,31781
+mGST/algorithm.py,sha256=2xeIiPP1ae8IgBgrc7boTk-NyirUMJimcZTvKMbZqKY,27504
 mGST/compatibility.py,sha256=00DsPnNfOtrQcDTvxBDs-0aMhmuXmOIIxl_Ohy-Emkg,8920
-mGST/low_level_jit.py,sha256=uE1D3v01FbPpsbP92C4220OQalzOfxgL1Ku89BNkxLY,27377
-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.43.dist-info/METADATA,sha256=ezkJGO1628fD-X8lXDqtZUeEK9y7kIsfZjDw-JqZBzs,10872
-iqm_benchmarks-2.43.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iqm_benchmarks-2.43.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.43.dist-info/RECORD,,
+mGST/low_level_jit.py,sha256=Ih1MxcwU0GnSRu0TI9GaYxpB94CMuJ8Is1eTeOwsfA8,30772
+mGST/optimization.py,sha256=x9tJ9wMQ5aONWpNpBMVtK0rwE6DRcOU33htNgrt0tx4,11015
+mGST/qiskit_interface.py,sha256=uCdn-Q9CXI2f4FQSxGUy8GmmzQhr9NhCOFb2VPj0gTs,10061
+mGST/reporting/figure_gen.py,sha256=xFPAHx1Trdqz7swn0kRqwc_jbRaNxhG9Nvx0jeitooo,25847
+mGST/reporting/reporting.py,sha256=Wss1-zFsMEhzrrXKfP-RICau80ezjDIzcN555KhSehc,34160
+iqm_benchmarks-2.45.dist-info/METADATA,sha256=a121AuXxTW_ziKGmIdEd-qjjBunWeV3iFEp60U4kT9o,10905
+iqm_benchmarks-2.45.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iqm_benchmarks-2.45.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.45.dist-info/RECORD,,

mGST/additional_fns.py

@@ -2,8 +2,10 @@
 Utility functions used by mGST modules
 """
 
+import contextlib
 import os
 import random
+import sys
 import warnings
 
 import numpy as np
@@ -13,6 +15,18 @@ from scipy.linalg import expm, qr
 from mGST.low_level_jit import Mp_norm_lower, MVE_lower, contract, local_basis
 
 
+@contextlib.contextmanager
+def suppress_stdout():
+    """Context manager to temporarily suppress stdout output."""
+    with open(os.devnull, "w", encoding="utf-8") as devnull:
+        old_stdout = sys.stdout
+        sys.stdout = devnull
+        try:
+            yield
+        finally:
+            sys.stdout = old_stdout
+
+
 def transp(dim1, dim2):
     """Superoperator of a map that performs the transpose operation
 
@@ -261,6 +275,10 @@ def random_gs(d, r, rK, n_povm):
         The second axis enumerates Kraus operators for a gate specified by the first axis.
     X: 3D numpy array
         Array where random CPT superoperators are stacked along the first axis.
+    E: 2D numpy array
+        Randomly generated POVM elements stacked along the first axis.
+    rho: 1D numpy array
+        Random initial state vector
 
     Notes:
         The Kraus operators are generated from random unitaries, see function randKrausSet
@@ -327,7 +345,7 @@ def perturbed_target_init(X_target, rK):
     """
     d, r, _ = X_target.shape
     pdim = int(np.sqrt(r))
-    K_perturb = randKrausSet(d, r, rK, a=0.1)
+    K_perturb = randKrausSet(d, r, rK, a=0.05)
     X_perturb = np.einsum("ijkl,ijnm -> iknlm", K_perturb, K_perturb.conj()).reshape((d, r, r))
     X_init = np.einsum("ikl,ilm ->ikm", X_perturb, X_target)
     K_init = Kraus_rep(X_init, d, pdim, rK)
@@ -627,8 +645,7 @@ def sampled_measurements(y, n):
         y_new = np.maximum(np.minimum(y, 1), 0)
         if np.sum(np.abs(y_new - y)) > 1e-6:
             warnings.warn(
-                f"Warning: Probabilities capped to interval [0,1]",
-                f"l1-difference to input:%f" % np.sum(np.abs(y_new - y)),
+                f"Warning: Probabilities capped to interval [0,1], l1-difference to input: {np.sum(np.abs(y_new - y))}"
             )
         y = y_new
     rng = np.random.default_rng()
@@ -723,24 +740,22 @@ def is_positive(X, E, rho):
     eigvals = np.array([la.eigvals(X_choi[i]) for i in range(d)])
     partial_traces = np.einsum("aiikl -> akl", X.reshape(d, pdim, pdim, pdim, pdim))
     povm_eigvals = np.array([la.eigvals(E[i].reshape(pdim, pdim)) for i in range(n_povm)])
-    if np.any(np.imag(eigvals.reshape(-1) > 1e-10)):
-        print("Gates are not all hermitian.")
-    else:
-        for i in range(d):
-            print(f"Gate %i positive:" % i, np.all(eigvals[i, :] > -1e-10))
-            print(f"Gate %i trace preserving:" % i, la.norm(partial_traces[i] - np.eye(pdim)) < 1e-10)
-    print(f"Initial state positive:", np.all(la.eigvals(rho.reshape(pdim, pdim)) > -1e-10))
-    print(f"Initial state normalization:", np.trace(rho.reshape(pdim, pdim)))
-    print(
-        "fPOVM valid:",
-        np.all(
-            [
-                la.norm(np.sum(E, axis=0).reshape(pdim, pdim) - np.eye(pdim)) < 1e-10,
-                np.all(povm_eigvals.reshape(-1) > -1e-10),
-            ]
-        ),
-    )
 
+    # Check if gates are hermitian
+    assert np.all(np.imag(eigvals.reshape(-1)) < 1e-10)
+
+    # Check if gates are positive and trace preserving
+    for i in range(d):
+        assert np.all(eigvals[i, :] > -1e-10)
+        assert la.norm(partial_traces[i] - np.eye(pdim)) < 1e-10
+
+    # Initial state positivity and normalization
+    assert np.all(la.eigvals(rho.reshape(pdim, pdim)) > -1e-10)
+    assert np.abs(np.trace(rho.reshape(pdim, pdim))) - 1 < 1e-10
+
+    # POVM positivity and normalization
+    assert la.norm(np.sum(E, axis=0).reshape(pdim, pdim) - np.eye(pdim)) < 1e-6
+    assert np.all(povm_eigvals.reshape(-1) > -1e-10)
 
 def tvd(X, E, rho, J, y_data):
     """Return the total variation distance between model probabilities for the circuits in J