iqm-benchmarks 2.26__py3-none-any.whl → 2.28__py3-none-any.whl

iqm/benchmarks/utils_plots.py

@@ -0,0 +1,233 @@
+# Copyright 2024 IQM Benchmarks developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Plotting and visualization utility functions
+"""
+from dataclasses import dataclass
+from typing import Dict, Literal, Optional, Tuple
+
+import matplotlib.pyplot as plt
+import networkx as nx
+import numpy as np
+from qiskit.transpiler import CouplingMap
+from rustworkx import PyGraph, spring_layout, visualization  # pylint: disable=no-name-in-module
+
+from iqm.benchmarks.utils import extract_fidelities
+
+
+@dataclass
+class GraphPositions:
+    """A class to store and generate graph positions for different chip layouts.
+
+    This class contains predefined node positions for various quantum chip topologies and
+    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 = {
+        0: (5.0, 7.0),
+        1: (6.0, 6.0),
+        2: (3.0, 7.0),
+        3: (4.0, 6.0),
+        4: (5.0, 5.0),
+        5: (6.0, 4.0),
+        6: (7.0, 3.0),
+        7: (2.0, 6.0),
+        8: (3.0, 5.0),
+        9: (4.0, 4.0),
+        10: (5.0, 3.0),
+        11: (6.0, 2.0),
+        12: (1.0, 5.0),
+        13: (2.0, 4.0),
+        14: (3.0, 3.0),
+        15: (4.0, 2.0),
+        16: (5.0, 1.0),
+        17: (1.0, 3.0),
+        18: (2.0, 2.0),
+        19: (3.0, 1.0),
+    }
+
+    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),
+    }
+
+
+    predefined_stations = {"garnet": garnet_positions, "deneb": deneb_positions}
+
+    @staticmethod
+    def create_positions(
+        graph: PyGraph, topology: Optional[Literal["star", "crystal"]] = None
+    ) -> Dict[int, Tuple[float, float]]:
+        """Generate node positions for a given graph and topology.
+
+        Args:
+            graph (PyGraph): The graph to generate positions for.
+            topology (Optional[Literal["star", "crystal"]]): The type of layout to generate. Must be either "star" or "crystal".
+
+        Returns:
+            Dict[int, Tuple[float, float]]: A dictionary mapping node indices to (x,y) coordinates.
+        """
+        n_nodes = len(graph.node_indices())
+
+        if topology == "star":
+            # Place center node at (0,0)
+            pos = {0: (0.0, 0.0)}
+
+            if n_nodes > 1:
+                # Place other nodes in a circle around the center
+                angles = np.linspace(0, 2 * np.pi, n_nodes - 1, endpoint=False)
+                radius = 1.0
+
+                for i, angle in enumerate(angles, start=1):
+                    x = radius * np.cos(angle)
+                    y = radius * np.sin(angle)
+                    pos[i] = (x, y)
+
+        # Crystal and other topologies
+        else:
+            # Fix first node position in bottom right
+            fixed_pos = {0: (1.0, 1.0)}  # For more consistent layouts
+
+            # Get spring layout with one fixed position
+            pos = {
+                int(k): (float(v[0]), float(v[1]))
+                for k, v in spring_layout(graph, scale=2, pos=fixed_pos, num_iter=300, fixed={0}).items()
+            }
+        return pos
+
+
+def plot_layout_fidelity_graph(
+    cal_url: str, qubit_layouts: Optional[list[list[int]]] = None, station: Optional[str] = None
+):
+    """Plot a graph showing the quantum chip layout with fidelity information.
+
+    Creates a visualization of the quantum chip topology where nodes represent qubits
+    and edges represent connections between qubits. Edge thickness indicates gate errors
+    (thinner edges mean better fidelity) and selected qubits are highlighted in orange.
+
+    Args:
+        cal_url: URL to retrieve calibration data from
+        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.
+
+    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))
+
+    # Add edges
+    graph.add_edges_from(edges_graph)
+
+    # 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)
+
+    # 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"
+
+    # 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))
+
+    # Draw the graph
+    visualization.mpl_draw(
+        graph,
+        with_labels=True,
+        node_color=node_colors,
+        pos=pos,
+        labels=lambda node: node,
+        width=7 * weights_ordered / np.max(weights_ordered),
+    )  # type: ignore[call-arg]
+
+    # Add edge labels using matplotlib's annotate
+    for edge in edges_graph:
+        x1, y1 = pos[edge[0]]
+        x2, y2 = pos[edge[1]]
+        x = (x1 + x2) / 2
+        y = (y1 + y2) / 2
+        plt.annotate(
+            f"{edge[2]:.1e}",
+            xy=(x, y),
+            xytext=(0, 0),
+            textcoords="offset points",
+            ha="center",
+            va="center",
+            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)"
+    )
+    plt.show()
+
+
+def rx_to_nx_graph(backend_coupling_map: CouplingMap) -> nx.Graph:
+    """Convert the Rustworkx graph returned by a backend to a Networkx graph.
+
+    Args:
+        backend_coupling_map (CouplingMap): The coupling map of the backend.
+
+    Returns:
+        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()))
+    backend_nx_graph = nx.Graph()
+    backend_nx_graph.add_nodes_from(backend_nodes)
+    backend_nx_graph.add_edges_from(backend_egdes)
+
+    return backend_nx_graph

iqm/benchmarks/utils_shadows.py

@@ -0,0 +1,228 @@
+# Copyright 2025 IQM Benchmarks developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Shadow Tomography utility functions
+"""
+
+import random
+from typing import Dict, List, Literal, Optional, Sequence, Tuple, cast
+
+import numpy as np
+from numpy.random import RandomState
+from qiskit import ClassicalRegister, QuantumCircuit, quantum_info
+from qiskit.circuit.library import UnitaryGate
+import scipy.linalg as spl
+
+from iqm.benchmarks.utils import timeit
+
+
+def CUE(random_gen: RandomState, n: int) -> np.ndarray:
+    """Prepares single qubit Haar-random unitary (drawn from Circuilar Unitary Ensemble - CUE).
+
+    Args:
+        random_gen (RandomState): a random generator.
+        n (int): the size of the matrix.
+    Returns:
+        np.ndarray: an n x n CUE matrix
+    """
+    # Generate an N × N complex matrix Z with standard normal entries
+    Z = (random_gen.randn(n, n) + 1j * random_gen.randn(n, n)) / np.sqrt(2.0)
+
+    # Perform QR decomposition, Z = QR
+    Q, R = spl.qr(Z)
+
+    # Create the diagonal matrix Lambda
+    Lambda = np.diag(R.diagonal() / np.abs(R.diagonal()))
+
+    # Compute U = Q * Lambda, which is Haar-distributed
+    U = Q @ Lambda
+
+    return U
+
+
+@timeit
+def local_shadow_tomography(
+    qc: QuantumCircuit,
+    Nu: int,
+    active_qubits: Sequence[int],
+    measure_other: Optional[Sequence[int]] = None,
+    measure_other_name: Optional[str] = None,
+    clifford_or_haar: Literal["clifford", "haar"] = "clifford",
+    cliffords_1q: Optional[Dict[str, QuantumCircuit]] = None,
+) -> Tuple[np.ndarray | Dict[str, List[str]], List[QuantumCircuit]]:
+    """
+    Prepares the circuits to perform local Haar or Clifford shadow tomography.
+
+    Args:
+        qc (QuantumCircuit): The quantum circuit to which random unitaries are appended.
+        Nu (int): Number of local random unitaries used.
+        active_qubits (Sequence[int]): The Sequence of active qubits.
+        measure_other (Optional[Sequence[int]]): Whether to measure other qubits in the qc QuantumCircuit.
+            * Default is None.
+        measure_other_name (Optional[str]): Name of the classical register to assign measure_other.
+        clifford_or_haar (Literal["clifford", "haar"]): Whether to use Clifford or Haar random 1Q gates.
+            * Default is "clifford".
+        cliffords_1q (Optional[Dict[str, QuantumCircuit]]): Dictionary of 1-qubit Cliffords in terms of IQM-native r and CZ gates.
+            * Default is None.
+
+    Raises:
+        ValueError: If clifford_or_haar is not "clifford" or "haar".
+        ValueError: If cliffords_1q is None and clifford_or_haar is "clifford".
+
+    Returns:
+        Tuple[np.ndarray | Dict[str, List[str]], List[QuantumCircuit]]:
+        - ndarray | Dict[str, List[str]]: Either:
+            * Unitary gate (numpy ndarray), composed of local unitaries for each random initialisation and qubit, if clifford_or_haar == 'haar'.
+            * Dictionary of lists of Clifford labels corresponding to each RM, keys being str(qubit), if clifford_or_haar == 'clifford'.
+        - List[QuantumCircuit]: List of tomography circuits.
+    """
+    if clifford_or_haar not in ["clifford", "haar"]:
+        raise ValueError("clifford_or_haar must be either 'clifford' or 'haar'.")
+    if clifford_or_haar == "clifford" and cliffords_1q is None:
+        raise ValueError("cliffords_1q dictionary must be provided if clifford_or_haar is 'clifford'.")
+    if clifford_or_haar == "clifford":
+        # Get the keys of the Clifford dictionaries
+        clifford_1q_keys = list(cast(Dict, cliffords_1q).keys())
+
+    qclist = []
+    seed = random.SystemRandom().randrange(2**32 - 1)  # Init Random Generator
+    random_gen: RandomState = np.random.RandomState(seed)  # pylint: disable=no-member
+
+    unitaries: Dict[str, List[str]] | np.ndarray
+    if clifford_or_haar == "haar":
+        unitaries = np.zeros((Nu, len(active_qubits), 2, 2), dtype=np.complex_)
+    else:
+        unitaries = {str(q): [] for q in active_qubits}
+
+    for u in range(Nu):
+        qc_copy = qc.copy()
+        for q_idx, qubit in enumerate(active_qubits):
+            if clifford_or_haar == "haar":
+                temp_U = CUE(random_gen, 2)
+                qc_copy.append(UnitaryGate(temp_U), [qubit])
+                cast(np.ndarray, unitaries)[u, q_idx, :, :] = np.array(temp_U)
+            elif clifford_or_haar == "clifford":
+                rand_key = random.choice(clifford_1q_keys)
+                c_1q = cast(dict, cliffords_1q)[rand_key]
+                qc_copy.compose(c_1q, qubits=[qubit], inplace=True)
+                cast(dict, unitaries)[str(qubit)].append(rand_key)
+
+        qc_copy.barrier()
+
+        register_rm = ClassicalRegister(len(active_qubits), "RMs")
+        qc_copy.add_register(register_rm)
+        qc_copy.measure(active_qubits, register_rm)
+
+        if measure_other is not None:
+            if measure_other_name is None:
+                measure_other_name = "non_RMs"
+            register_neighbors = ClassicalRegister(len(measure_other), measure_other_name)
+            qc_copy.add_register(register_neighbors)
+            qc_copy.measure(measure_other, register_neighbors)
+
+        qclist.append(qc_copy)
+
+    return unitaries, qclist
+
+
+def get_local_shadow(
+    counts: Dict[str, int],
+    unitary_arg: np.ndarray | Sequence[str],
+    subsystem_bit_indices: Sequence[int],
+    clifford_or_haar: Literal["clifford", "haar"] = "clifford",
+    cliffords_1q: Optional[Dict[str, QuantumCircuit]] = None,
+) -> np.ndarray:
+    """Constructs shadows for each individual initialisation.
+
+    Args:
+        counts (Dict[str, int]): a dictionary of bit-string counts.
+        unitary_arg (np.ndarray | Sequence[str]): local random unitaries used for a given initialisation, either specified as
+                    - a numpy array, or
+                    - a Sequence of Clifford labels.
+        subsystem_bit_indices (Sequence[int]): Bit indices in the counts of the subsystem to construct the shadow of.
+        clifford_or_haar (Literal["clifford", "haar"]): Whether to use Clifford or Haar random 1Q gates.
+                * Default is "clifford".
+        cliffords_1q (Optional[Dict[str, QuantumCircuit]]): dictionary of 1-qubit Cliffords in terms of IQM-native r and CZ gates
+                * Default is None.
+
+    Returns:
+        np.ndarray: shadow of considered subsystem.
+    """
+    if clifford_or_haar not in ["clifford", "haar"]:
+        raise ValueError("clifford_or_haar must be either 'clifford' or 'haar'.")
+    if clifford_or_haar == "clifford" and cliffords_1q is None:
+        raise ValueError("cliffords_1q dictionary must be provided if clifford_or_haar is 'clifford'.")
+    if clifford_or_haar == "haar" and isinstance(unitary_arg, Sequence):
+        raise ValueError("If clifford_or_haar is 'haar', the unitary operator must be a numpy array.")
+    if clifford_or_haar == "clifford" and not isinstance(unitary_arg, Sequence):
+        raise ValueError(
+            "If clifford_or_haar is 'clifford', the unitary operator must be specified as a Sequence of strings."
+        )
+
+    nqubits = len(subsystem_bit_indices)
+    rhoshadows = np.zeros([2**nqubits, 2**nqubits], dtype=complex)
+    proj = np.zeros((2, 2, 2), dtype=complex)
+    proj[0, :, :] = np.array([[1, 0], [0, 0]])
+    proj[1, :, :] = np.array([[0, 0], [0, 1]])
+    shots = sum(list(counts.values()))
+
+    unitary_op: np.ndarray
+    if clifford_or_haar == "haar":
+        unitary_op = cast(np.ndarray, unitary_arg)
+    else:
+        unitary_op = np.zeros((nqubits, 2, 2), dtype=complex)
+        for qubit_idx, clif_label in enumerate(unitary_arg):
+            unitary_op[qubit_idx, :, :] = quantum_info.Operator(cast(dict, cliffords_1q)[clif_label]).to_matrix()
+
+    for bit_strings in counts.keys():
+        rho_j: int | np.ndarray = 1
+        for j in subsystem_bit_indices:
+            s_j = int(bit_strings[::-1][j])
+            rho_j = np.kron(
+                rho_j,
+                3
+                * np.einsum(
+                    "ab,bc,cd", np.transpose(np.conjugate(unitary_op[j, :, :])), proj[s_j, :, :], unitary_op[j, :, :]
+                )
+                - np.array([[1, 0], [0, 1]]),
+            )
+
+        rhoshadows += rho_j * counts[bit_strings] / shots
+
+    return rhoshadows
+
+
+def get_negativity(rho: np.ndarray, NA: int, NB: int) -> float:
+    """Computes the negativity of a given density matrix.
+    Note that a negativity >0 is only a necessary and sufficient condition for entanglement if NA = NB = 1. For more    qubits per subsystems it is merely a necessary condition.
+    Args:
+        rho (np.ndarray): Density matrix.
+        NA (int): Number of qubits for subsystem A.
+        NB (int): Number of qubits for subsystem B.
+    Returns:
+        float: the negativity of the input density matrix.
+    """
+    da = 2**NA
+    db = 2**NB
+    rho = rho.reshape(da, db, da, db)
+    # TODO: # pylint: disable=fixme
+    #  This is a one-liner here, but generally it would be nicer to have
+    #  a partial transpose function w.r.t. any subsystem in the utils file!
+    rho_t = np.einsum("ijkl -> kjil", rho)
+    rho_t = rho_t.reshape(2 ** (NA + NB), 2 ** (NA + NB))
+    evals, _ = np.linalg.eig(rho_t)
+    neg = np.sum([np.abs(i) - i for i in np.real(evals)]) / 2
+
+    return neg

{iqm_benchmarks-2.26.dist-info → iqm_benchmarks-2.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.26
+Version: 2.28
 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
@@ -16,10 +16,11 @@ Requires-Dist: matplotlib<4,>=3.6.3
 Requires-Dist: more-itertools<11.0.0,>=10.1.0
 Requires-Dist: mthree<2.7,>=2.6
 Requires-Dist: networkx<4.0,>=3.3
-Requires-Dist: rustworkx>=0.15.1
+Requires-Dist: rustworkx>=0.16.0
 Requires-Dist: numpy<2.0,>=1.25.2
-Requires-Dist: qiskit<2.0,>=1.0
-Requires-Dist: qiskit-iqm<16.0,>=15.1
+Requires-Dist: qiskit<2.0,>=1.2.4
+Requires-Dist: qiskit-iqm<18.0,>=17.8
+Requires-Dist: iqm-client>=22.7
 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
@@ -68,6 +69,7 @@ Below is a list of the benchmarks currently available in the suite:
   - CLOPS [[arXiv:2110.14108 [quant-ph]](https://arxiv.org/abs/2110.14108) (2021)]
 * Entanglement:
   - GHZ State Fidelity [[arXiv:0712.0921 [quant-ph]](https://arxiv.org/abs/0712.0921) (2007)]
+  - Graph State Bipartite Entanglement [[Adv. Quantum Technol., 2100061](https://doi.org/10.1002/qute.202100061) (2021)]
 * Optimization:
   - Q-Score [[IEEE Trans. Quantum Eng., 2](https://doi.org/10.1109/TQE.2021.3090207) (2021)]
 

{iqm_benchmarks-2.26.dist-info → iqm_benchmarks-2.28.dist-info}/RECORD

@@ -1,43 +1,46 @@
-iqm/benchmarks/__init__.py,sha256=8SRHlADqZjlP8PtbKTMvu-ejpcEZkW8cPmgW8GVKJg8,2638
+iqm/benchmarks/__init__.py,sha256=74NuBycITM-CV7nx0l1T2wbnQDdVmF8jTZVE0KpG7pc,2773
 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=_1iLsc-azCE4ucHlD1LLRPdTryUKaMs8r75q3njRugE,33451
+iqm/benchmarks/utils.py,sha256=2aEwFhZAHBmqLjSMtnqjuWcXCyMX3vpUfF-vqoeBIHw,38517
+iqm/benchmarks/utils_plots.py,sha256=Y2AQdY92hopDEWmM5KUvF79OqEBTNAUgahwomjhEKZE,8036
+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=SZ4IbRYDTDTc_5DK7wXOeP_QIY48vA63I7JkPdwVbgs,36374
-iqm/benchmarks/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=jSPcdFf1Xsq09EJXKCVHzNXjQIdAoDg859279wKGjaQ,41075
+iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=jA1MaXIyPBwxbN36mTjn_jKaRO5-NdoG0YV-RaujU3s,36450
+iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
+iqm/benchmarks/entanglement/ghz.py,sha256=RGA6ynJFsfaCJv0nKccsiIzPk2G-iHHvIeW8LVu30HY,41249
+iqm/benchmarks/entanglement/graph_states.py,sha256=okWdpASQewZ62UaHks2N-tvCgCsUtIkz8dBoX1xh6Jk,62512
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=ufkIKuh0XtiSVn-3Deca-7Ky1cXZ1CxCXMN-j-Lhevw,38132
+iqm/benchmarks/optimization/qscore.py,sha256=KOw8fjXeMwCjYvKukpX7IiAqRQrVTkrnIgKjNCPVWdw,38130
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=xlziaxjhJUNyHjBCMzMLeJ9PcFNBtDO7urKvCTBb4sI,31471
-iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=4ll3R8AX-BA599TEaMBzE2rJtAzHLtCkq8CaSkJfA0Y,36626
+iqm/benchmarks/quantum_volume/clops.py,sha256=fD_eh10qHv_W-_mCA-PjPDIxNJ5sqD7yDkK1UjRsAAo,31474
+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=vvSd0pRWxtzyirohO9yf_58mjevkc2-pbuWIEb-4gaw,46928
-iqm/benchmarks/randomized_benchmarking/clifford_2q.pkl,sha256=ZipqU3crPhz2T35qGFgB4GvMyoi_7pnu8NqW5ZP8NXg,90707258
+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=pe9wSFvQ6Vh7rWZNZalIKOeaHoXc8iT4pkvrcLmY75g,42352
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=MryufwrOCBcZZHDeX9WGHVtYhFz2XtS3xLm6YQYEAM4,43160
 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/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=QAivrFMV98JELa28tTV4DkW7XKuSU2I5sL6lkg6syUs,34994
-iqm_benchmarks-2.26.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=_xdp8XLPcZyuqy7Xz8-K8H7zjgRo9ZxFiDgCXE72gaE,34997
+iqm_benchmarks-2.28.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=SRwC1sVFShRVxQDfH1bhUvnquvgwJFLSiZ70qo5SwxE,26314
+mGST/algorithm.py,sha256=QnxLJtxZysggLUtbZE-c2MWaFclZB2XUVJhvrmUvjVs,26315
 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.26.dist-info/METADATA,sha256=yrczoXmgJh34bMhbo-XTomCKT9XowiP6hw61tpxacUQ,10555
-iqm_benchmarks-2.26.dist-info/WHEEL,sha256=tTnHoFhvKQHCh4jz3yCn0WPTYIy7wXx3CJtJ7SJGV7c,91
-iqm_benchmarks-2.26.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.26.dist-info/RECORD,,
+iqm_benchmarks-2.28.dist-info/METADATA,sha256=sRwA84uA95W9hBB-hy5KYVZFvOg6eSwhQVC9nTjMFLw,10710
+iqm_benchmarks-2.28.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+iqm_benchmarks-2.28.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.28.dist-info/RECORD,,

{iqm_benchmarks-2.26.dist-info → iqm_benchmarks-2.28.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.1)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

mGST/algorithm.py

@@ -727,7 +727,7 @@ def run_mGST(
         qcvv_logger.info(f"Convergence criterion satisfied")
     else:
         qcvv_logger.info(
-            f"Convergence criterion not satisfied,inspect results and consider increasing max_iter or using new initializations.",
+            f"Convergence criterion not satisfied, inspect results and consider increasing max_iter or using new initializations.",
         )
     qcvv_logger.info(
         f"Final objective {Decimal(res_list[-1]):.2e} in time {(time.time() - t0):.2f}s",