iqm-benchmarks 1.3__py3-none-any.whl → 1.5__py3-none-any.whl

iqm/benchmarks/__init__.py

@@ -18,9 +18,33 @@ IQM's Python Library Benchmarking Suite QCVV.
 
 from importlib.metadata import PackageNotFoundError, version
 
-from .benchmark_definition import AnalysisResult, Benchmark, RunResult
+from .benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+)
+from .entanglement.ghz import GHZBenchmark, GHZConfiguration
+from .quantum_volume.clops import CLOPSBenchmark, CLOPSConfiguration
+from .quantum_volume.quantum_volume import QuantumVolumeBenchmark, QuantumVolumeConfiguration
+from .randomized_benchmarking.clifford_rb.clifford_rb import CliffordRandomizedBenchmarking, CliffordRBConfiguration
+from .randomized_benchmarking.interleaved_rb.interleaved_rb import (
+    InterleavedRandomizedBenchmarking,
+    InterleavedRBConfiguration,
+)
+from .randomized_benchmarking.mirror_rb.mirror_rb import MirrorRandomizedBenchmarking, MirrorRBConfiguration
 
 
+AVAILABLE_BENCHMARKS = {
+    GHZBenchmark.name: GHZBenchmark,
+    CLOPSBenchmark.name: CLOPSBenchmark,
+    QuantumVolumeBenchmark.name: QuantumVolumeBenchmark,
+    CliffordRandomizedBenchmarking.name: CliffordRandomizedBenchmarking,
+    InterleavedRandomizedBenchmarking.name: InterleavedRandomizedBenchmarking,
+    MirrorRandomizedBenchmarking.name: MirrorRandomizedBenchmarking,
+}
+
 try:
     # Change here if project is renamed and does not equal the package name
     dist_name = "iqm-benchmarks"

iqm/benchmarks/benchmark_definition.py

@@ -21,7 +21,7 @@ import copy
 from copy import deepcopy
 from dataclasses import dataclass, field
 import functools
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 import uuid
 
 from matplotlib.figure import Figure
@@ -35,7 +35,44 @@ from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMFacadeBackend
 
 
 @dataclass
-class RunResult:
+class BenchmarkObservationIdentifier:
+    """Identifier for observations for ease of use
+
+    Attributes:
+        qubit_indices: list containing the indices of the qubits the observation was executed on.
+    """
+
+    qubit_indices: list[int]
+
+    @property
+    def string_identifier(self) -> str:
+        """String version of the qubit indices for ease of use
+
+        Returns:
+            A string of the qubit indices
+        """
+        return str(self.qubit_indices)
+
+
+@dataclass
+class BenchmarkObservation:
+    """Dataclass to store the main results of a single run of a Benchmark
+
+    Attributes:
+        name: name of the observation
+        value: value of the observation
+        identifier: identifier, which should be a string of the qubit layout
+        uncertainty: uncertainty of the observation
+    """
+
+    name: str
+    value: Any
+    identifier: BenchmarkObservationIdentifier
+    uncertainty: Optional[Any] = None
+
+
+@dataclass
+class BenchmarkRunResult:
     """
     A dataclass that stores the results of a single run of a Benchmark.
 
@@ -47,7 +84,7 @@ class RunResult:
 
 
 @dataclass
-class AnalysisResult:
+class BenchmarkAnalysisResult:
     """
     A dataclass storing the results of the analysis.
 
@@ -58,7 +95,7 @@ class AnalysisResult:
 
     dataset: xr.Dataset
     plots: dict[str, Figure] = field(default_factory=lambda: ({}))
-    observations: dict[str, Any] = field(default_factory=lambda: ({}))
+    observations: list[BenchmarkObservation] = field(default_factory=lambda: [])
 
     def plot(self, plot_name: str):
         """
@@ -78,7 +115,7 @@ class AnalysisResult:
             plt.show()
 
     @classmethod
-    def from_run_result(cls, run: RunResult):
+    def from_run_result(cls, run: BenchmarkRunResult):
         """
         Creates a new ``AnalysisResult`` from a ``RunResult``.
 
@@ -88,7 +125,7 @@ class AnalysisResult:
         return cls(dataset=run.dataset)
 
 
-def default_analysis_function(result: AnalysisResult) -> AnalysisResult:
+def default_analysis_function(result: BenchmarkAnalysisResult) -> BenchmarkAnalysisResult:
     """
     The default analysis that only pass the result through.
     """
@@ -201,7 +238,7 @@ class Benchmark(ABC):
         # From exa_support MR
         self.options = copy.copy(self.default_options) if self.default_options else {}
         self.options.update(kwargs)
-        self.runs: list[RunResult] = []
+        self.runs: list[BenchmarkRunResult] = []
 
     @classmethod
     @abstractmethod
@@ -224,7 +261,7 @@ class Benchmark(ABC):
             the benchmark results.
         """
 
-    def run(self, calibration_set_id: str | uuid.UUID | None = None) -> RunResult:
+    def run(self, calibration_set_id: str | uuid.UUID | None = None) -> BenchmarkRunResult:
         """
         Runs the benchmark using the given backend and calibration_set_id.
 
@@ -236,13 +273,15 @@ class Benchmark(ABC):
             RunResult: The result of the benchmark run.
         """
         backend_for_execute = copy.copy(self.backend)
-        backend_for_execute.run = functools.partial(self.backend.run, calibration_set_id=calibration_set_id)  # type: ignore
+        backend_for_execute.run = functools.partial(
+            self.backend.run, calibration_set_id=calibration_set_id
+        )  # type: ignore
         dataset = self.execute(backend_for_execute)
-        run = RunResult(dataset)
+        run = BenchmarkRunResult(dataset)
         self.runs.append(run)
         return run
 
-    def analyze(self, run_index=-1) -> AnalysisResult:
+    def analyze(self, run_index=-1) -> BenchmarkAnalysisResult:
         """
         The default analysis for the benchmark.
 
@@ -259,6 +298,6 @@ class Benchmark(ABC):
             the ``analysis_function`` field.
         """
         run = self.runs[run_index]
-        result = AnalysisResult.from_run_result(run)
+        result = BenchmarkAnalysisResult.from_run_result(run)
         updated_result = self.analysis_function(result)
         return updated_result

iqm/benchmarks/entanglement/ghz.py

@@ -31,9 +31,15 @@ from qiskit_aer import Aer
 from scipy.spatial.distance import hamming
 import xarray as xr
 
-from iqm.benchmarks import Benchmark
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import AnalysisResult, RunResult, add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (
@@ -231,7 +237,7 @@ def fidelity_ghz_coherences(dataset: xr.Dataset, qubit_layout: List[int]) -> Lis
     return [fidelity]
 
 
-def fidelity_analysis(run: RunResult) -> AnalysisResult:
+def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analyze counts and compute the state fidelity
 
     Args:
@@ -242,12 +248,12 @@ def fidelity_analysis(run: RunResult) -> AnalysisResult:
         AnalysisResult
             An object containing the dataset, plots, and observations
     """
-    observations = {}
     dataset = run.dataset
     routine = dataset.attrs["fidelity_routine"]
     qubit_layouts = dataset.attrs["custom_qubits_array"]
     backend_name = dataset.attrs["backend_name"]
 
+    observation_list: list[BenchmarkObservation] = []
     for qubit_layout in qubit_layouts:
         if routine == "randomized_measurements":
             ideal_simulator = Aer.get_backend("statevector_simulator")
@@ -261,16 +267,33 @@ def fidelity_analysis(run: RunResult) -> AnalysisResult:
                     ideal_probabilities.append(
                         dict(sorted(ideal_simulator.run(deflated_qc).result().get_counts().items()))
                     )
-                result_dict = fidelity_ghz_randomized_measurements(
-                    dataset, qubit_layout, ideal_probabilities, len(qubit_layout)
+                observation_list.extend(
+                    [
+                        BenchmarkObservation(
+                            name=key, identifier=BenchmarkObservationIdentifier(qubit_layout), value=value
+                        )
+                        for key, value in fidelity_ghz_randomized_measurements(
+                            dataset, qubit_layout, ideal_probabilities, len(qubit_layout)
+                        ).items()
+                    ]
                 )
         else:  # default routine == "coherences":
             fidelity = fidelity_ghz_coherences(dataset, qubit_layout)
-            result_dict = {"fidelity": fidelity[0]}
+            observation_list.extend(
+                [
+                    BenchmarkObservation(
+                        name="fidelity", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[0]
+                    )
+                ]
+            )
             if len(fidelity) > 1:
-                result_dict.update({"fidelity_rem": fidelity[1]})
-        observations[str(qubit_layout)] = result_dict
-    return AnalysisResult(dataset=dataset, observations=observations)
+
+                observation_list.append(
+                    BenchmarkObservation(
+                        name="fidelity_rem", identifier=BenchmarkObservationIdentifier(qubit_layout), value=fidelity[1]
+                    )
+                )
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observation_list)
 
 
 def generate_ghz_linear(num_qubits: int) -> QuantumCircuit:
@@ -506,6 +529,7 @@ class GHZBenchmark(Benchmark):
     """The GHZ Benchmark estimates the quality of generated Greenberger-Horne-Zeilinger states"""
 
     analysis_function = staticmethod(fidelity_analysis)
+    name = "ghz"
 
     def __init__(self, backend: IQMBackendBase, configuration: "GHZConfiguration"):
         """Construct the GHZBenchmark class.
@@ -541,9 +565,9 @@ class GHZBenchmark(Benchmark):
 
         self.timestamp = strftime("%Y%m%d-%H%M%S")
 
-    @staticmethod
-    def name() -> str:
-        return "ghz"
+    # @staticmethod
+    # def name() -> str:
+    #     return "ghz"
 
     def generate_native_ghz(self, qubit_layout: List[int], qubit_count: int, routine: str) -> QuantumCircuit:
         """
@@ -704,7 +728,7 @@ class GHZBenchmark(Benchmark):
 
         for key, value in self.configuration:
             if key == "benchmark":  # Avoid saving the class object
-                dataset.attrs[key] = value.name()
+                dataset.attrs[key] = value.name
             else:
                 dataset.attrs[key] = value
         dataset.attrs[f"backend_name"] = self.backend.name

iqm/benchmarks/quantum_volume/clops.py

@@ -31,7 +31,7 @@ import xarray as xr
 
 from iqm.benchmarks import Benchmark
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import AnalysisResult, RunResult
+from iqm.benchmarks.benchmark_definition import BenchmarkAnalysisResult, BenchmarkRunResult
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import (
     count_2q_layers,
@@ -222,7 +222,7 @@ def retrieve_clops_elapsed_times(job_meta: Dict[str, Dict[str, Any]]) -> Dict[st
     return overall_elapsed
 
 
-def clops_analysis(run: RunResult) -> AnalysisResult:
+def clops_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a CLOPS (v or h) experiment
 
     Args:
@@ -252,7 +252,8 @@ def clops_analysis(run: RunResult) -> AnalysisResult:
 
     transpiled_qc_list = []
     for _, value in dataset.attrs["transpiled_circuits"].items():
-        transpiled_qc_list.extend(value)
+        for _, transpiled_circuit in value.items():
+            transpiled_qc_list.extend(transpiled_circuit)
 
     # CLOPS_V
     clops_v: float = num_circuits * num_updates * num_shots * depth / clops_time
@@ -310,7 +311,7 @@ def clops_analysis(run: RunResult) -> AnalysisResult:
     # Sort the final dataset
     dataset.attrs = dict(sorted(dataset.attrs.items()))
 
-    return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+    return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
 
 class CLOPSBenchmark(Benchmark):
@@ -396,8 +397,15 @@ class CLOPSBenchmark(Benchmark):
 
         """
         qcvv_logger.info(f"Adding all circuits to the dataset")
-        dataset.attrs["untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs["transpiled_circuits"] = self.transpiled_circuits
+        for key, circuit in zip(
+            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
+        ):
+            dictionary = {}
+            for outer_key, outer_value in circuit.items():
+                dictionary[str(outer_key)] = {
+                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
+                }
+            dataset.attrs[key] = dictionary
 
     def append_parameterized_unitary(
         self,
@@ -614,8 +622,11 @@ class CLOPSBenchmark(Benchmark):
             # Sort circuits according to their final measurement mappings
             (sorted_transpiled_qc_list, _), self.time_sort_batches = sort_batches_by_final_layout(transpiled_qc_list)
 
-        self.untranspiled_circuits.update({tuple(self.qubits): qc_list})
-        self.transpiled_circuits.update(sorted_transpiled_qc_list)
+        self.untranspiled_circuits.update({str(self.qubits): {str(self.qubits): qc_list}})
+        self.transpiled_circuits.update(
+            {str(self.qubits): {str(key): value for key, value in sorted_transpiled_qc_list.items()}}
+        )
+        # self.transpiled_circuits[str(self.qubits)].update(sorted_transpiled_qc_list)
 
         return sorted_transpiled_qc_list
 

iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -33,9 +33,15 @@ import xarray as xr
 # import iqm.diqe.executors.dynamical_decoupling.dd_high_level as dd
 # from iqm.diqe.executors.dynamical_decoupling.dynamical_decoupling_core import DDStrategy
 # from iqm.diqe.mapomatic import evaluate_costs, get_calibration_fidelities, get_circuit, matching_layouts
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (  # execute_with_dd,
@@ -281,7 +287,7 @@ def plot_hop_threshold(
     return fig_name, fig
 
 
-def qv_analysis(run: RunResult) -> AnalysisResult:
+def qv_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a Quantum Volume experiment
 
     Args:
@@ -291,8 +297,8 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
     """
 
     plots = {}
-    observations = {}
-    dataset = run.dataset
+    observations: list[BenchmarkObservation] = []
+    dataset = run.dataset.copy(deep=True)
     backend_name = dataset.attrs["backend_name"]
     execution_timestamp = dataset.attrs["execution_timestamp"]
     num_circuits = dataset.attrs["num_circuits"]
@@ -333,17 +339,24 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         # Compute the HO probabilities
         qv_result = compute_heavy_output_probabilities(execution_results[str(qubits)], ideal_heavy_outputs[str(qubits)])
 
-        processed_results = {
-            "average_heavy_output_probability": {
-                "value": cumulative_hop(qv_result)[-1],
-                "uncertainty": cumulative_std(qv_result)[-1],
-            },
-            "is_successful": {"value": str(is_successful(qv_result, num_sigmas)), "uncertainty": np.NaN},
-            "QV_result": {
-                "value": 2 ** len(qubits) if is_successful(qv_result, num_sigmas) else 1,
-                "uncertainty": np.NaN,
-            },
-        }
+        observations = [
+            BenchmarkObservation(
+                name="average_heavy_output_probability",
+                value=cumulative_hop(qv_result)[-1],
+                uncertainty=cumulative_std(qv_result)[-1],
+                identifier=BenchmarkObservationIdentifier(qubits),
+            ),
+            BenchmarkObservation(
+                name="is_succesful",
+                value=is_successful(qv_result, num_sigmas),
+                identifier=BenchmarkObservationIdentifier(qubits),
+            ),
+            BenchmarkObservation(
+                name="QV_result",
+                value=2 ** len(qubits) if is_successful(qv_result) else 1,
+                identifier=BenchmarkObservationIdentifier(qubits),
+            ),
+        ]
 
         dataset.attrs[qubits_idx].update(
             {
@@ -354,9 +367,6 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
             }
         )
 
-        # UPDATE OBSERVATIONS
-        observations.update({qubits_idx: processed_results})
-
         fig_name, fig = plot_hop_threshold(
             qubits,
             depth[str(qubits)],
@@ -370,7 +380,7 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         plots[fig_name] = fig
 
     if not rem:
-        return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+        return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
     # When REM is set to True, do the post-processing with the adjusted quasi-probabilities
     mit_shots = dataset.attrs["mit_shots"]
@@ -388,18 +398,6 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
             ideal_heavy_outputs[str(qubits)],
         )
 
-        rem_results = {
-            "REM_average_heavy_output_probability": {
-                "value": cumulative_hop(qv_result_rem)[-1],
-                "uncertainty": cumulative_std(qv_result_rem)[-1],
-            },
-            "REM_is_successful": {"value": str(is_successful(qv_result_rem)), "uncertainty": np.NaN},
-            "REM_QV_result": {
-                "value": 2 ** len(qubits) if is_successful(qv_result_rem, num_sigmas) else 1,
-                "uncertainty": np.NaN,
-            },
-        }
-
         dataset.attrs[qubits_idx].update(
             {
                 "sorted_qc_list_indices": (sorted_qc_list_indices if physical_layout == "batching" else None),
@@ -410,7 +408,26 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         )
 
         # UPDATE OBSERVATIONS
-        observations.update({qubits_idx: rem_results})
+        observations.extend(
+            [
+                BenchmarkObservation(
+                    name="REM_average_heavy_output_probability",
+                    value=cumulative_hop(qv_result_rem)[-1],
+                    uncertainty=cumulative_std(qv_result_rem)[-1],
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                ),
+                BenchmarkObservation(
+                    name="REM_is_succesful",
+                    value=is_successful(qv_result_rem, num_sigmas),
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                ),
+                BenchmarkObservation(
+                    name="REM_QV_result",
+                    value=2 ** len(qubits) if is_successful(qv_result_rem) else 1,
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                ),
+            ]
+        )
 
         fig_name_rem, fig_rem = plot_hop_threshold(
             qubits,
@@ -424,7 +441,7 @@ def qv_analysis(run: RunResult) -> AnalysisResult:
         )
         plots[fig_name_rem] = fig_rem
 
-    return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+    return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
 
 class QuantumVolumeBenchmark(Benchmark):
@@ -509,8 +526,15 @@ class QuantumVolumeBenchmark(Benchmark):
 
         """
         qcvv_logger.info(f"Adding all circuits to the dataset")
-        dataset.attrs["untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs["transpiled_circuits"] = self.transpiled_circuits
+        for key, circuit in zip(
+            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
+        ):
+            dictionary = {}
+            for outer_key, outer_value in circuit.items():
+                dictionary[str(outer_key)] = {
+                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
+                }
+            dataset.attrs[key] = dictionary
 
     # def get_mapomatic_average_qv_scores(self) -> List[List[int]]:
     #     """Estimate the average mapomatic scores for N quantum volume circuit samples
@@ -786,7 +810,9 @@ class QuantumVolumeBenchmark(Benchmark):
                         "time_submit": job_dict["time_submit"],
                         "time_retrieve": time_retrieve,
                         "all_job_metadata": all_job_metadata,
-                        "sorted_qc_list_indices": sorted_qc_list_indices[str(qubits)],
+                        "sorted_qc_list_indices": {
+                            str(key): value for key, value in sorted_qc_list_indices[str(qubits)].items()
+                        },
                         "operation_counts": all_op_counts[str(qubits)],
                     }
                 }

iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -23,9 +23,15 @@ import numpy as np
 from qiskit import QuantumCircuit
 import xarray as xr
 
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -45,7 +51,7 @@ from iqm.benchmarks.utils import retrieve_all_counts, retrieve_all_job_metadata,
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
-def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
+def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a Clifford RB experiment
 
     Args:
@@ -53,8 +59,9 @@ def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
     Returns:
         AnalysisResult corresponding to Clifford RB
     """
-    dataset = run.dataset
-    observations = {}
+    dataset = run.dataset.copy(deep=True)
+    observations: list[BenchmarkObservation] = []
+    obs_dict = {}
     plots = {}
 
     is_parallel_execution = dataset.attrs["parallel_execution"]
@@ -118,13 +125,13 @@ def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
 
         processed_results = {
             "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
-            "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},
-            "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
-            "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
         }
 
         dataset.attrs[qubits_idx].update(
             {
+                "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},
+                "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
+                "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
                 "fidelities": fidelities[str(qubits)],
                 "avg_fidelities_nominal_values": average_fidelities,
                 "avg_fidelities_stderr": stddevs_from_mean,
@@ -139,13 +146,24 @@ def clifford_rb_analysis(run: RunResult) -> AnalysisResult:
             }
         )
 
-        observations.update({qubits_idx: processed_results})
+        obs_dict.update({qubits_idx: processed_results})
+        observations.extend(
+            [
+                BenchmarkObservation(
+                    name=key,
+                    identifier=BenchmarkObservationIdentifier(qubits),
+                    value=values["value"],
+                    uncertainty=values["uncertainty"],
+                )
+                for key, values in processed_results.items()
+            ]
+        )
 
         # Generate individual decay plots
-        fig_name, fig = plot_rb_decay("clifford", [qubits], dataset, observations)
+        fig_name, fig = plot_rb_decay("clifford", [qubits], dataset, obs_dict)
         plots[fig_name] = fig
 
-    return AnalysisResult(dataset=dataset, observations=observations, plots=plots)
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)
 
 
 class CliffordRandomizedBenchmarking(Benchmark):
@@ -176,7 +194,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
         self.session_timestamp = strftime("%Y%m%d-%H%M%S")
         self.execution_timestamp = ""
 
-    def add_all_meta_to_dataset(self, dataset: xr.Dataset):
+    def add_all_metadata_to_dataset(self, dataset: xr.Dataset):
         """Adds all configuration metadata and circuits to the dataset variable
         Args:
             dataset (xr.Dataset): The xarray dataset
@@ -215,7 +233,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
         validate_rb_qubits(self.qubits_array, backend)
 
         dataset = xr.Dataset()
-        self.add_all_meta_to_dataset(dataset)
+        self.add_all_metadata_to_dataset(dataset)
 
         clifford_1q_dict, clifford_2q_dict = import_native_gate_cliffords()
 

iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -24,9 +24,15 @@ import numpy as np
 from qiskit import QuantumCircuit
 import xarray as xr
 
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import (
+    Benchmark,
+    BenchmarkAnalysisResult,
+    BenchmarkObservation,
+    BenchmarkObservationIdentifier,
+    BenchmarkRunResult,
+    add_counts_to_dataset,
+)
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -48,7 +54,7 @@ from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
 # pylint: disable=too-many-statements, too-many-branches
-def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
+def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for an Interleaved RB experiment
 
     Args:
@@ -56,8 +62,9 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
     Returns:
         AnalysisResult corresponding to Interleaved RB
     """
-    dataset = run.dataset
-    observations: Dict[int, Any] = {}
+    dataset = run.dataset.copy(deep=True)
+    obs_dict: Dict[int, Any] = {}
+    observations: list[BenchmarkObservation] = []
     plots: Dict[str, Figure] = {}
 
     is_parallel_execution = dataset.attrs["parallel_execution"]
@@ -160,14 +167,26 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
 
             processed_results[rb_type] = {
                 "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
-                "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},
-                "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
-                "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
             }
 
+            observations.extend(
+                [
+                    BenchmarkObservation(
+                        name=f"{key}_{rb_type}",
+                        identifier=BenchmarkObservationIdentifier(qubits),
+                        value=values["value"],
+                        uncertainty=values["uncertainty"],
+                    )
+                    for key, values in processed_results[rb_type].items()
+                ]
+            )
+
             dataset.attrs[qubits_idx].update(
                 {
                     rb_type: {
+                        "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},
+                        "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
+                        "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
                         "fidelities": fidelities[str(qubits)][rb_type],
                         "avg_fidelities_nominal_values": average_fidelities,
                         "avg_fidelities_stderr": stddevs_from_mean,
@@ -183,7 +202,7 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
                 }
             )
 
-        observations.update({qubits_idx: processed_results})
+        obs_dict.update({qubits_idx: processed_results})
 
         # Generate decay plots
         if interleaved_gate_parameters is None:
@@ -196,19 +215,19 @@ def interleaved_rb_analysis(run: RunResult) -> AnalysisResult:
             "irb",
             [qubits],
             dataset,
-            observations,
+            obs_dict,
             interleaved_gate=interleaved_gate_string,
         )
         plots[fig_name] = fig
 
     # Rearrange observations
-    observations_refactored: Dict[int, Dict[str, Dict[str, float]]] = {}
-    for k, o in observations.items():
-        observations_refactored[k] = {}
-        for rb_type in o.keys():
-            observations_refactored[k].update({f"{k}_{rb_type}": v for k, v in o[rb_type].items()})
+    # observations_refactored: Dict[int, Dict[str, Dict[str, float]]] = {}
+    # for k, o in obs_dict.items():
+    #     observations_refactored[k] = {}
+    #     for rb_type in o.keys():
+    #         observations_refactored[k].update({f"{k}_{rb_type}": v for k, v in o[rb_type].items()})
 
-    return AnalysisResult(dataset=dataset, observations=observations_refactored, plots=plots)
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)
 
 
 class InterleavedRandomizedBenchmarking(Benchmark):
@@ -216,14 +235,14 @@ class InterleavedRandomizedBenchmarking(Benchmark):
 
     analysis_function = staticmethod(interleaved_rb_analysis)
 
-    name: str = "clifford_rb"
+    name: str = "interleaved_clifford_rb"
 
     def __init__(self, backend_arg: IQMBackendBase | str, configuration: "InterleavedRBConfiguration"):
         """Construct the InterleavedRandomizedBenchmark class
 
         Args:
             backend_arg (IQMBackendBase | str): the backend to execute Clifford RB on
-            configuration (CliffordRBConfiguration): The Clifford RB configuration
+            configuration (InterleavedRBConfiguration): The Clifford RB configuration
         """
         super().__init__(backend_arg, configuration)
 

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -15,9 +15,9 @@ from qiskit_aer import Aer
 from scipy.spatial.distance import hamming
 import xarray as xr
 
-from iqm.benchmarks import AnalysisResult, Benchmark, RunResult
+from iqm.benchmarks import BenchmarkAnalysisResult, BenchmarkRunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import Benchmark, add_counts_to_dataset
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -404,7 +404,7 @@ def list_to_numcircuit_times_numpauli_matrix(
 
 
 # pylint: disable=too-many-statements
-def mrb_analysis(run: RunResult) -> AnalysisResult:
+def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     """Analysis function for a MRB experiment
 
     Args:
@@ -414,7 +414,7 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
     """
     plots = {}
     observations = {}
-    dataset = run.dataset
+    dataset = run.dataset.copy(deep=True)
 
     shots = dataset.attrs["shots"]
     num_circuit_samples = dataset.attrs["num_circuit_samples"]
@@ -468,7 +468,7 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
             # Execute the quantum circuits on the simulated, ideal backend
             # pylint: disable=unbalanced-tuple-unpacking
             all_noiseless_jobs, _ = submit_execute(
-                {tuple(qubits): transpiled_circuits[str(qubits)][depth]},
+                {tuple(qubits): transpiled_circuits[str(qubits)][str(depth)]},
                 simulator,
                 shots,
                 calset_id=None,
@@ -508,13 +508,13 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
 
         processed_results = {
             "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
-            "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},
-            "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
-            "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
         }
 
         dataset.attrs[qubits_idx].update(
             {
+                "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},
+                "fit_amplitude": {"value": popt["amplitude"].value, "uncertainty": popt["amplitude"].stderr},
+                "fit_offset": {"value": popt["offset"].value, "uncertainty": popt["offset"].stderr},
                 "polarizations": polarizations,
                 "avg_polarization_nominal_values": average_polarizations,
                 "avg_polatization_stderr": stddevs_from_mean,
@@ -554,7 +554,7 @@ def mrb_analysis(run: RunResult) -> AnalysisResult:
     )
     plots[fig_name] = fig
 
-    return AnalysisResult(dataset=dataset, plots=plots, observations=observations)
+    return BenchmarkAnalysisResult(dataset=dataset, plots=plots, observations=observations)
 
 
 class MirrorRandomizedBenchmarking(Benchmark):
@@ -564,7 +564,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
 
     analysis_function = staticmethod(mrb_analysis)
 
-    name: str = "mrb"
+    name: str = "mirror_rb"
 
     def __init__(self, backend_arg: IQMBackendBase | str, configuration: "MirrorRBConfiguration"):
         """Construct the MirrorRandomizedBenchmarking class
@@ -617,8 +617,15 @@ class MirrorRandomizedBenchmarking(Benchmark):
             dataset (xr.Dataset):  The xarray dataset
         """
         qcvv_logger.info(f"Adding all circuits to the dataset")
-        dataset.attrs["untranspiled_circuits"] = self.untranspiled_circuits
-        dataset.attrs["transpiled_circuits"] = self.transpiled_circuits
+        for key, circuit in zip(
+            ["transpiled_circuits", "untranspiled_circuits"], [self.transpiled_circuits, self.untranspiled_circuits]
+        ):
+            dictionary = {}
+            for outer_key, outer_value in circuit.items():
+                dictionary[str(outer_key)] = {
+                    str(inner_key): inner_values for inner_key, inner_values in outer_value.items()
+                }
+            dataset.attrs[key] = dictionary
 
     def submit_single_mrb_job(
         self,
@@ -733,10 +740,10 @@ class MirrorRandomizedBenchmarking(Benchmark):
                 qcvv_logger.info(f"Job for layout {qubits} & depth {depth} submitted successfully!")
 
             self.untranspiled_circuits[str(qubits)] = {
-                d: mrb_untranspiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
+                str(d): mrb_untranspiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
             }
             self.transpiled_circuits[str(qubits)] = {
-                d: mrb_transpiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
+                str(d): mrb_transpiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
             }
 
             dataset.attrs[qubits_idx] = {"qubits": qubits}

iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py

@@ -614,13 +614,13 @@ def plot_rb_decay(
             str(q): observations[q_idx]["avg_gate_fidelity"]["uncertainty"] for q_idx, q in enumerate(qubits_array)
         }
         decay_rate[identifier] = {
-            str(q): observations[q_idx]["decay_rate"]["value"] for q_idx, q in enumerate(qubits_array)
+            str(q): dataset.attrs[q_idx]["decay_rate"]["value"] for q_idx, q in enumerate(qubits_array)
         }
         offset[identifier] = {
-            str(q): observations[q_idx]["fit_offset"]["value"] for q_idx, q in enumerate(qubits_array)
+            str(q): dataset.attrs[q_idx]["fit_offset"]["value"] for q_idx, q in enumerate(qubits_array)
         }
         amplitude[identifier] = {
-            str(q): observations[q_idx]["fit_amplitude"]["value"] for q_idx, q in enumerate(qubits_array)
+            str(q): dataset.attrs[q_idx]["fit_amplitude"]["value"] for q_idx, q in enumerate(qubits_array)
         }
     else:
         rb_type_keys = list(observations[0].keys())
@@ -648,13 +648,14 @@ def plot_rb_decay(
                 for q_idx, q in enumerate(qubits_array)
             }
             decay_rate[rb_type] = {
-                str(q): observations[q_idx][rb_type]["decay_rate"]["value"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx][rb_type]["decay_rate"]["value"] for q_idx, q in enumerate(qubits_array)
             }
+            print(dataset.attrs)
             offset[rb_type] = {
-                str(q): observations[q_idx][rb_type]["fit_offset"]["value"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx][rb_type]["fit_offset"]["value"] for q_idx, q in enumerate(qubits_array)
             }
             amplitude[rb_type] = {
-                str(q): observations[q_idx][rb_type]["fit_amplitude"]["value"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx][rb_type]["fit_amplitude"]["value"] for q_idx, q in enumerate(qubits_array)
             }
 
     for index_irb, key in enumerate(rb_type_keys):

{iqm_benchmarks-1.3.dist-info → iqm_benchmarks-1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-benchmarks
-Version: 1.3
+Version: 1.5
 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>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -15,14 +15,14 @@ Requires-Dist: lmfit==1.3.1
 Requires-Dist: matplotlib==3.9.0
 Requires-Dist: more-itertools==10.1.0
 Requires-Dist: mthree==2.6.3
-Requires-Dist: networkx==2.8.8
-Requires-Dist: numpy>=1.24.2
+Requires-Dist: networkx==3.3
+Requires-Dist: numpy>=1.25.2
 Requires-Dist: qiskit==0.45.3
 Requires-Dist: qiskit-aer==0.13.3
 Requires-Dist: qiskit-iqm==15.1
 Requires-Dist: scikit-optimize==0.10.2
 Requires-Dist: tabulate==0.9.0
-Requires-Dist: uncertainties==3.2.1
+Requires-Dist: uncertainties==3.2.2
 Requires-Dist: pycurl==7.45.3
 Requires-Dist: xarray==2024.6.0
 Requires-Dist: types-pycurl

{iqm_benchmarks-1.3.dist-info → iqm_benchmarks-1.5.dist-info}/RECORD

@@ -1,6 +1,6 @@
-iqm/benchmarks/__init__.py,sha256=OPL9DS7yU21ZYrYGJ_VGpSeWH-CpW_iq5w0mSPx7bAE,1055
+iqm/benchmarks/__init__.py,sha256=7EOYlsJriQHKAlb3tHpPY4bh4wLbsssZg4NV0XW0WBU,2128
 iqm/benchmarks/benchmark.py,sha256=SGhBcSxLPUu-cVXAjG4Db2TRobFCRBYoE1NtTDK1lJg,4432
-iqm/benchmarks/benchmark_definition.py,sha256=1VxXaJBUHuiLh1VgSuG7xUfZ8ZxTMxrN7IkzQdnvBzw,9232
+iqm/benchmarks/benchmark_definition.py,sha256=zdsZcZm8U_C9PVhgktKPF0AX8neu-6VdWjtcCua2XEs,10310
 iqm/benchmarks/benchmark_experiment.py,sha256=0BFNn04jyD1Yj-pIKnuZjCD00v3pU5EnwkRzJUBc0n4,6540
 iqm/benchmarks/logging_config.py,sha256=U7olP5Kr75AcLJqNODf9VBhJLVqIvA4AYR6J39D5rww,1052
 iqm/benchmarks/readout_mitigation.py,sha256=cx8K2EAjhYfVKGSRlpoh9xBFQZZhyL63wPMtzNL3hAg,12329
@@ -8,23 +8,23 @@ iqm/benchmarks/utils.py,sha256=fNuGkN_GI73nZD6xDN_r97Pr6I8uIDhPXZqdQkQvDpM,21291
 iqm/benchmarks/compressive_gst/__init__.py,sha256=4F_5YxExn4ysGQaEs-WNfm0yiFBxkKtGAYBZFWnRsSk,915
 iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=iLBG6HBPfW3y4EYs6DItuBjqBbMQIoCFsJlUSgH_w8w,46288
 iqm/benchmarks/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=T7HCYmI9pCZn5JuONZMc_J-zFxxf2ioIQ-iMHBOQ8u4,35242
+iqm/benchmarks/entanglement/ghz.py,sha256=BFadLxux6vGWz1IlKOJkQA_qKAOa6HR63vhwrREZelI,36058
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
 iqm/benchmarks/optimization/qscore.py,sha256=_s5_w5QTlaeDcHX1BmAevVctHOTVobee1eGkFx7DTEs,27942
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=8HxCNaI5_ZUBgRqE6hQkcR7Exc-E9INv4GFvv-QF--U,30837
-iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=An1NUsS5ekuDn4fk7MrS1B-YRoG4cboPwGQd4YMuQ5M,35839
+iqm/benchmarks/quantum_volume/clops.py,sha256=GSuDnAB-XzFP7DLVsYC9zjvf7NAQqQHIgX0TAxiFvOs,31451
+iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=jnVh1A-WC9DjpE8nvVIa87Ov9iihB17NOh8aiwjlu0I,36883
 iqm/benchmarks/randomized_benchmarking/__init__.py,sha256=IkKo-7zUChxZZd3my_csQCJfJfZNsV3-JTvdG8uqys4,734
 iqm/benchmarks/randomized_benchmarking/clifford_1q.pkl,sha256=SVcye1bsjxf1hvC1ku2vHOIZQRG5hy1loAOugpVhUE8,42517
 iqm/benchmarks/randomized_benchmarking/clifford_2q.pkl,sha256=BLDpXdyDGkFUxCMHyUMDBnNclCQTsty-kIXwiuY31eA,82994083
 iqm/benchmarks/randomized_benchmarking/multi_lmfit.py,sha256=Se1ygR4mXn_2_P82Ch31KBnCmY-g_A9NKzE9Ir8nEvw,3247
-iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=RZX1G9PBCwqwHk_ylqPHLtWk3GMN5Tc2OchnaEv9W2Y,37824
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=hKe3qz2dQtcGEOODhcEP1OBH3e68ryDYFiYJ0PDGEJs,37863
 iqm/benchmarks/randomized_benchmarking/clifford_rb/__init__.py,sha256=bTDA156LAl7OLGcMec--1nzDrV1XpPRVq3CquTmucgE,677
-iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=0zaFjzz95aDsZ7dxV5-rXd8lGOSk9KuCXZBtk988I8M,16911
+iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=uo6cPhoQQ9qAGeZFZG23jxaR88_qKdiqtlBrG_mAGWg,17470
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
-iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=kZHS3_FnwgVAt4_UmOmwl5DRDO24dKNV6epAGxGRM-U,25563
+iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=hTjjitBp0CEkOnvZj_byJ2CzPHiwXaDhxIO8O8dcAj4,26205
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=ZekEqI_89nXzGO1vjM-b5Uwwicy59M4fYHXfA-f0MIg,674
-iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=yDYJePSG6kcW0aa3Xw5GHris5L7Sry3JWemvEW5iH2o,34060
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=v1UOCVK4_fcOB2VNjMqQB8tp4JwytjdY7RM_lXAtFy0,34463
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
@@ -35,8 +35,8 @@ mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
 mGST/qiskit_interface.py,sha256=2XuJ4WFViLsHCTpEZncwsLbRr-cELEYhegTpRPzCcuI,10080
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
 mGST/reporting/reporting.py,sha256=-XBy3OCJIMOsA8cApwKjhVKBwnjSAoxm-voHNbRWytM,25803
-iqm_benchmarks-1.3.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-1.3.dist-info/METADATA,sha256=Xl9uaemgivU4KTvjrt9A0nF97TFNyKfHputsfiKl4KI,8378
-iqm_benchmarks-1.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-iqm_benchmarks-1.3.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-1.3.dist-info/RECORD,,
+iqm_benchmarks-1.5.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-1.5.dist-info/METADATA,sha256=y5aehxY2SokKgSxMNB4COxxCoJKhJh-ogMeO0ft6cmM,8376
+iqm_benchmarks-1.5.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+iqm_benchmarks-1.5.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-1.5.dist-info/RECORD,,