iqm-benchmarks 1.12__py3-none-any.whl → 2.1__py3-none-any.whl

iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -20,7 +20,6 @@ from time import strftime
 from typing import Any, Dict, List, Sequence, Type
 
 import numpy as np
-from qiskit import QuantumCircuit
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
@@ -32,6 +31,7 @@ from iqm.benchmarks.benchmark_definition import (
     BenchmarkRunResult,
     add_counts_to_dataset,
 )
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -48,6 +48,7 @@ from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common impor
     validate_rb_qubits,
 )
 from iqm.benchmarks.utils import retrieve_all_counts, retrieve_all_job_metadata, timeit, xrvariable_to_counts
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -242,8 +243,8 @@ class CliffordRandomizedBenchmarking(Benchmark):
         time_circuit_generation: Dict[str, float] = {}
 
         # Initialize the variable to contain the circuits for each layout
-        self.untranspiled_circuits: Dict[str, Dict[int, List[QuantumCircuit]]] = {}
-        self.transpiled_circuits: Dict[str, Dict[int, List[QuantumCircuit]]] = {}
+        self.untranspiled_circuits = BenchmarkCircuit("untranspiled_circuits")
+        self.transpiled_circuits = BenchmarkCircuit("transpiled_circuits")
 
         # Auxiliary dict from str(qubits) to indices
         qubit_idx: Dict[str, Any] = {}
@@ -291,13 +292,18 @@ class CliffordRandomizedBenchmarking(Benchmark):
                 )
                 qcvv_logger.info(f"Job for sequence length {seq_length} submitted successfully!")
 
-            self.untranspiled_circuits[str(self.qubits_array)] = {
-                m: parallel_untranspiled_rb_circuits[m] for m in self.sequence_lengths
-            }
-            self.transpiled_circuits[str(self.qubits_array)] = {
-                m: parallel_transpiled_rb_circuits[m] for m in self.sequence_lengths
-            }
-
+                self.untranspiled_circuits.circuit_groups.append(
+                    CircuitGroup(
+                        name=f"{str(self.qubits_array)}_length_{seq_length}",
+                        circuits=parallel_untranspiled_rb_circuits[seq_length],
+                    )
+                )
+                self.transpiled_circuits.circuit_groups.append(
+                    CircuitGroup(
+                        name=f"{str(self.qubits_array)}_length_{seq_length}",
+                        circuits=parallel_transpiled_rb_circuits[seq_length],
+                    )
+                )
             qubit_idx = {str(self.qubits_array): "parallel_all"}
             dataset.attrs["parallel_all"] = {"qubits": self.qubits_array}
             dataset.attrs.update({q_idx: {"qubits": q} for q_idx, q in enumerate(self.qubits_array)})
@@ -347,8 +353,12 @@ class CliffordRandomizedBenchmarking(Benchmark):
                     f"All jobs for qubits {qubits} and sequence lengths {self.sequence_lengths} submitted successfully!"
                 )
 
-                self.untranspiled_circuits[str(qubits)] = rb_untranspiled_circuits[str(qubits)]
-                self.transpiled_circuits[str(qubits)] = rb_transpiled_circuits[str(qubits)]
+                self.untranspiled_circuits.circuit_groups.append(
+                    CircuitGroup(name=str(qubits), circuits=rb_untranspiled_circuits[str(qubits)])
+                )
+                self.transpiled_circuits.circuit_groups.append(
+                    CircuitGroup(name=str(qubits), circuits=rb_transpiled_circuits[str(qubits)])
+                )
 
                 dataset.attrs[qubits_idx] = {"qubits": qubits}
 
@@ -377,9 +387,8 @@ class CliffordRandomizedBenchmarking(Benchmark):
             qcvv_logger.info(f"Adding counts of qubits {qubits} and depth {depth} run to the dataset")
             dataset, _ = add_counts_to_dataset(execution_results, identifier, dataset)
 
-        self.add_all_circuits_to_dataset(dataset)
-
         qcvv_logger.info(f"RB experiment concluded !")
+        self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 
         return dataset
 

iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -21,7 +21,6 @@ from typing import Any, Dict, List, Literal, Optional, Sequence, Type
 
 from matplotlib.figure import Figure
 import numpy as np
-from qiskit import QuantumCircuit
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
@@ -33,6 +32,7 @@ from iqm.benchmarks.benchmark_definition import (
     BenchmarkRunResult,
     add_counts_to_dataset,
 )
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -50,6 +50,7 @@ from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common impor
     validate_rb_qubits,
 )
 from iqm.benchmarks.utils import retrieve_all_counts, retrieve_all_job_metadata, timeit, xrvariable_to_counts
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -220,13 +221,6 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         )
         plots[fig_name] = fig
 
-    # Rearrange observations
-    # 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 BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)
 
 
@@ -310,9 +304,9 @@ class InterleavedRandomizedBenchmarking(Benchmark):
         time_circuit_generation: Dict[str, float] = {}
 
         # Initialize the variable to contain the circuits for each layout
-        self.untranspiled_circuits: Dict[str, Dict[int, List[QuantumCircuit]]] = {}
-        self.transpiled_circuits: Dict[str, Dict[int, List[QuantumCircuit]]] = {}
 
+        self.untranspiled_circuits = BenchmarkCircuit("untranspiled_circuits")
+        self.transpiled_circuits = BenchmarkCircuit("transpiled_circuits")
         # Validate and get interleaved gate as a QC
         interleaved_gate_qc = validate_irb_gate(
             self.interleaved_gate, backend, gate_params=self.interleaved_gate_params
@@ -407,18 +401,30 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                 )
                 qcvv_logger.info(f"Both jobs for sequence length {seq_length} submitted successfully!")
 
-            self.untranspiled_circuits[str(self.qubits_array)] = {
-                m: parallel_untranspiled_rb_circuits[m] for m in self.sequence_lengths
-            }
-            self.transpiled_circuits[str(self.qubits_array)] = {
-                m: parallel_transpiled_rb_circuits[m] for m in self.sequence_lengths
-            }
-            self.untranspiled_circuits[str(self.qubits_array) + "_interleaved"] = {
-                m: parallel_untranspiled_interleaved_rb_circuits[m] for m in self.sequence_lengths
-            }
-            self.transpiled_circuits[str(self.qubits_array) + "_interleaved"] = {
-                m: parallel_transpiled_interleaved_rb_circuits[m] for m in self.sequence_lengths
-            }
+            self.untranspiled_circuits.circuit_groups.append(
+                CircuitGroup(
+                    name=str(self.qubits_array),
+                    circuits=[parallel_untranspiled_rb_circuits[m] for m in self.sequence_lengths],
+                )
+            )
+            self.transpiled_circuits.circuit_groups.append(
+                CircuitGroup(
+                    name=str(self.qubits_array),
+                    circuits=[parallel_transpiled_rb_circuits[m] for m in self.sequence_lengths],
+                )
+            )
+            self.untranspiled_circuits.circuit_groups.append(
+                CircuitGroup(
+                    name=f"{str(self.qubits_array)}_interleaved",
+                    circuits=[parallel_untranspiled_interleaved_rb_circuits[m] for m in self.sequence_lengths],
+                )
+            )
+            self.transpiled_circuits.circuit_groups.append(
+                CircuitGroup(
+                    name=f"{str(self.qubits_array)}_interleaved",
+                    circuits=[parallel_transpiled_interleaved_rb_circuits[m] for m in self.sequence_lengths],
+                )
+            )
 
             qubit_idx = {str(self.qubits_array): "parallel_all"}
             dataset.attrs["parallel_all"] = {"qubits": self.qubits_array}
@@ -502,12 +508,25 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                     f"All jobs for qubits {qubits} and sequence lengths {self.sequence_lengths} submitted successfully!"
                 )
 
-                self.untranspiled_circuits[str(qubits)] = rb_untranspiled_circuits[str(qubits)]
-                self.transpiled_circuits[str(qubits)] = rb_transpiled_circuits[str(qubits)]
-                self.untranspiled_circuits[str(qubits) + "_interleaved"] = rb_untranspiled_interleaved_circuits[
-                    str(qubits)
-                ]
-                self.transpiled_circuits[str(qubits) + "_interleaved"] = rb_transpiled_interleaved_circuits[str(qubits)]
+                self.untranspiled_circuits.circuit_groups.append(
+                    CircuitGroup(name=str(qubits), circuits=[rb_untranspiled_circuits[str(qubits)]])
+                )
+                self.transpiled_circuits.circuit_groups.append(
+                    CircuitGroup(name=str(qubits), circuits=[rb_transpiled_circuits[str(qubits)]])
+                )
+
+                self.untranspiled_circuits.circuit_groups.append(
+                    CircuitGroup(
+                        name=f"{str(qubits)}_interleaved", circuits=[rb_untranspiled_interleaved_circuits[str(qubits)]]
+                    )
+                )
+                self.transpiled_circuits.circuit_groups.append(
+                    CircuitGroup(
+                        name=f"{str(qubits)}_interleaved",
+                        # name=str(qubits),
+                        circuits=[rb_transpiled_interleaved_circuits[str(qubits)]],
+                    )
+                )
 
                 dataset.attrs[qubits_idx] = {"qubits": qubits}
 
@@ -539,9 +558,8 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                 qcvv_logger.info(f"Adding counts of qubits {qubits} and depth {depth} run to the dataset")
                 dataset, _ = add_counts_to_dataset(execution_results, identifier, dataset)
 
-        self.add_all_circuits_to_dataset(dataset)
-
         qcvv_logger.info(f"Interleaved RB experiment concluded !")
+        self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 
         return dataset
 

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -9,7 +9,7 @@ from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, cast
 import warnings
 
 import numpy as np
-from qiskit import QuantumCircuit, transpile
+from qiskit import transpile
 from qiskit.quantum_info import random_clifford, random_pauli
 from qiskit_aer import Aer
 from scipy.spatial.distance import hamming
@@ -18,6 +18,7 @@ import xarray as xr
 from iqm.benchmarks import BenchmarkAnalysisResult, BenchmarkRunResult
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.benchmark_definition import Benchmark, add_counts_to_dataset
+from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common import (
     exponential_rb,
@@ -34,6 +35,7 @@ from iqm.benchmarks.utils import (
     timeit,
     xrvariable_to_counts,
 )
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -443,7 +445,7 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     else:
         assigned_mrb_depths = {str(qubits_array[i]): [2 * m for m in depths_array[i]] for i in range(len(depths_array))}
 
-    transpiled_circuits = dataset.attrs["transpiled_circuits"]
+    transpiled_circuits = run.circuits["transpiled_circuits"]
     simulator = Aer.get_backend("qasm_simulator")
 
     all_noisy_counts: Dict[str, Dict[int, List[Dict[str, int]]]] = {}
@@ -468,7 +470,7 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             # 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)][str(depth)]},
+                {tuple(qubits): transpiled_circuits[f"{str(qubits)}_depth_{str(depth)}"].circuits},
                 simulator,
                 shots,
                 calset_id=None,
@@ -610,23 +612,6 @@ class MirrorRandomizedBenchmarking(Benchmark):
                 dataset.attrs[key] = value
         # Defined outside configuration - if any
 
-    @timeit
-    def add_all_circuits_to_dataset(self, dataset: xr.Dataset):
-        """Adds all generated circuits during execution to the dataset variable
-        Args:
-            dataset (xr.Dataset):  The xarray dataset
-        """
-        qcvv_logger.info(f"Adding all circuits to the dataset")
-        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,
         backend_arg: IQMBackendBase,
@@ -674,8 +659,8 @@ class MirrorRandomizedBenchmarking(Benchmark):
         time_circuit_generation: Dict[str, float] = {}
 
         # Initialize the variable to contain the circuits for each layout
-        self.untranspiled_circuits: Dict[str, Dict[int | str, List[QuantumCircuit]]] = {}
-        self.transpiled_circuits: Dict[str, Dict[int | str, List[QuantumCircuit]]] = {}
+        self.untranspiled_circuits = BenchmarkCircuit("untranspiled_circuits")
+        self.transpiled_circuits = BenchmarkCircuit("transpiled_circuits")
 
         # The depths should be assigned to each set of qubits!
         # The real final MRB depths are twice the originally specified, must be taken into account here!
@@ -699,8 +684,6 @@ class MirrorRandomizedBenchmarking(Benchmark):
         qubit_idx: Dict[str, Any] = {}
         for qubits_idx, qubits in enumerate(self.qubits_array):
             qubit_idx[str(qubits)] = qubits_idx
-            self.untranspiled_circuits[str(qubits)] = {}
-            self.transpiled_circuits[str(qubits)] = {}
 
             qcvv_logger.info(
                 f"Executing MRB on qubits {qubits}."
@@ -739,12 +722,12 @@ class MirrorRandomizedBenchmarking(Benchmark):
                 all_mrb_jobs.append(self.submit_single_mrb_job(backend, qubits, depth, sorted_transpiled_qc_list))
                 qcvv_logger.info(f"Job for layout {qubits} & depth {depth} submitted successfully!")
 
-            self.untranspiled_circuits[str(qubits)] = {
-                str(d): mrb_untranspiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
-            }
-            self.transpiled_circuits[str(qubits)] = {
-                str(d): mrb_transpiled_circuits_lists[d] for d in assigned_mrb_depths[str(qubits)]
-            }
+                self.untranspiled_circuits.circuit_groups.append(
+                    CircuitGroup(name=f"{str(qubits)}_depth_{depth}", circuits=mrb_untranspiled_circuits_lists[depth])
+                )
+                self.transpiled_circuits.circuit_groups.append(
+                    CircuitGroup(name=f"{str(qubits)}_depth_{depth}", circuits=mrb_transpiled_circuits_lists[depth])
+                )
 
             dataset.attrs[qubits_idx] = {"qubits": qubits}
 
@@ -774,7 +757,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
             qcvv_logger.info(f"Adding counts of qubits {qubits} and depth {depth} run to the dataset")
             dataset, _ = add_counts_to_dataset(execution_results, f"qubits_{str(qubits)}_depth_{str(depth)}", dataset)
 
-        self.add_all_circuits_to_dataset(dataset)
+        self.circuits = Circuits([self.transpiled_circuits, self.untranspiled_circuits])
 
         qcvv_logger.info(f"MRB experiment execution concluded !")
 

iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py

@@ -29,13 +29,14 @@ from matplotlib.collections import PolyCollection
 from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 import numpy as np
-from qiskit import QuantumCircuit, transpile
+from qiskit import transpile
 from qiskit.quantum_info import Clifford
 import xarray as xr
 
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.multi_lmfit import create_multi_dataset_params, multi_dataset_residual
 from iqm.benchmarks.utils import get_iqm_backend, marginal_distribution, submit_execute, timeit
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm import optimize_single_qubit_gates
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
@@ -564,6 +565,11 @@ def plot_rb_decay(
     num_circuit_samples = dataset.attrs["num_circuit_samples"]
     timestamp = dataset.attrs["execution_timestamp"]
     backend_name = dataset.attrs["backend_name"]
+    # If only one layout is passed, the index to retrieve results must be shifted!
+    qubits_index = 0
+    if len(qubits_array) == 1:
+        config_qubits_array = dataset.attrs["qubits_array"]
+        qubits_index = config_qubits_array.index(qubits_array[0])
 
     # Fetch the relevant observations indexed by qubit layouts
     depths = {}
@@ -582,79 +588,93 @@ def plot_rb_decay(
         colors = [cmap(i) for i in np.linspace(start=1, stop=0, num=len(qubits_array)).tolist()]
         if identifier == "mrb":
             depths[identifier] = {
-                str(q): list(dataset.attrs[q_idx]["polarizations"].keys()) for q_idx, q in enumerate(qubits_array)
+                str(q): list(dataset.attrs[q_idx]["polarizations"].keys())
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             polarizations[identifier] = {
-                str(q): dataset.attrs[q_idx]["polarizations"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx]["polarizations"] for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             average_polarizations[identifier] = {
-                str(q): dataset.attrs[q_idx]["avg_polarization_nominal_values"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx]["avg_polarization_nominal_values"]
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             stddevs_from_mean[identifier] = {
-                str(q): dataset.attrs[q_idx]["avg_polatization_stderr"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx]["avg_polatization_stderr"]
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
-        else:
+        else:  # identifier == "clifford"
             depths[identifier] = {
-                str(q): list(dataset.attrs[q_idx]["fidelities"].keys()) for q_idx, q in enumerate(qubits_array)
+                str(q): list(dataset.attrs[q_idx]["fidelities"].keys())
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             polarizations[identifier] = {
-                str(q): dataset.attrs[q_idx]["fidelities"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx]["fidelities"] for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             average_polarizations[identifier] = {
-                str(q): dataset.attrs[q_idx]["avg_fidelities_nominal_values"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx]["avg_fidelities_nominal_values"]
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             stddevs_from_mean[identifier] = {
-                str(q): dataset.attrs[q_idx]["avg_fidelities_stderr"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx]["avg_fidelities_stderr"]
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
         # These are common to both MRB and standard Clifford
         fidelity_value[identifier] = {
-            str(q): observations[q_idx]["avg_gate_fidelity"]["value"] for q_idx, q in enumerate(qubits_array)
+            str(q): observations[q_idx]["avg_gate_fidelity"]["value"]
+            for q_idx, q in enumerate(qubits_array, qubits_index)
         }
         fidelity_stderr[identifier] = {
-            str(q): observations[q_idx]["avg_gate_fidelity"]["uncertainty"] for q_idx, q in enumerate(qubits_array)
+            str(q): observations[q_idx]["avg_gate_fidelity"]["uncertainty"]
+            for q_idx, q in enumerate(qubits_array, qubits_index)
         }
         decay_rate[identifier] = {
-            str(q): dataset.attrs[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, qubits_index)
         }
         offset[identifier] = {
-            str(q): dataset.attrs[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, qubits_index)
         }
         amplitude[identifier] = {
-            str(q): dataset.attrs[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, qubits_index)
         }
-    else:
+    else:  # id MRB
         rb_type_keys = list(observations[0].keys())
         colors = [cmap(i) for i in np.linspace(start=1, stop=0, num=len(rb_type_keys)).tolist()]
         for rb_type in rb_type_keys:
             depths[rb_type] = {
-                str(q): list(dataset.attrs[q_idx][rb_type]["fidelities"].keys()) for q_idx, q in enumerate(qubits_array)
+                str(q): list(dataset.attrs[q_idx][rb_type]["fidelities"].keys())
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             polarizations[rb_type] = {
-                str(q): dataset.attrs[q_idx][rb_type]["fidelities"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx][rb_type]["fidelities"]
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             average_polarizations[rb_type] = {
                 str(q): dataset.attrs[q_idx][rb_type]["avg_fidelities_nominal_values"]
-                for q_idx, q in enumerate(qubits_array)
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             stddevs_from_mean[rb_type] = {
-                str(q): dataset.attrs[q_idx][rb_type]["avg_fidelities_stderr"] for q_idx, q in enumerate(qubits_array)
+                str(q): dataset.attrs[q_idx][rb_type]["avg_fidelities_stderr"]
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             fidelity_value[rb_type] = {
                 str(q): observations[q_idx][rb_type]["avg_gate_fidelity"]["value"]
-                for q_idx, q in enumerate(qubits_array)
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             fidelity_stderr[rb_type] = {
                 str(q): observations[q_idx][rb_type]["avg_gate_fidelity"]["uncertainty"]
-                for q_idx, q in enumerate(qubits_array)
+                for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             decay_rate[rb_type] = {
-                str(q): dataset.attrs[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, qubits_index)
             }
             offset[rb_type] = {
-                str(q): dataset.attrs[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, qubits_index)
             }
             amplitude[rb_type] = {
-                str(q): dataset.attrs[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, qubits_index)
             }
 
     for index_irb, key in enumerate(rb_type_keys):

iqm/benchmarks/readout_mitigation.py

@@ -25,10 +25,11 @@ from mthree.classes import QuasiCollection
 from mthree.exceptions import M3Error
 from mthree.mitigation import _job_thread
 from mthree.utils import final_measurement_mapping
-from qiskit import QuantumCircuit, transpile  # pylint: disable = no-name-in-module
+from qiskit import transpile  # pylint: disable = no-name-in-module
 from qiskit.providers import Backend, BackendV1, BackendV2
 
 from iqm.benchmarks.utils import get_iqm_backend, timeit
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 

iqm/benchmarks/utils.py

@@ -25,12 +25,13 @@ from typing import Any, Dict, Iterable, List, Literal, Optional, Sequence, Tuple
 from more_itertools import chunked
 from mthree.utils import final_measurement_mapping
 import numpy as np
-from qiskit import ClassicalRegister, QuantumCircuit, transpile
+from qiskit import ClassicalRegister, transpile
 from qiskit.converters import circuit_to_dag
 from qiskit.transpiler import CouplingMap
 import xarray as xr
 
 from iqm.benchmarks.logging_config import qcvv_logger
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm import transpile_to_IQM
 from iqm.qiskit_iqm.fake_backends.fake_adonis import IQMFakeAdonis
 from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo

{iqm_benchmarks-1.12.dist-info → iqm_benchmarks-2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-benchmarks
-Version: 1.12
+Version: 2.1
 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

{iqm_benchmarks-1.12.dist-info → iqm_benchmarks-2.1.dist-info}/RECORD

@@ -1,31 +1,32 @@
-iqm/benchmarks/__init__.py,sha256=7EOYlsJriQHKAlb3tHpPY4bh4wLbsssZg4NV0XW0WBU,2128
+iqm/benchmarks/__init__.py,sha256=sAS6OKctANSzgVUEUWugQs9mcKwG9KOTBEsbSYGxtPc,2201
 iqm/benchmarks/benchmark.py,sha256=SGhBcSxLPUu-cVXAjG4Db2TRobFCRBYoE1NtTDK1lJg,4432
-iqm/benchmarks/benchmark_definition.py,sha256=aRpOmeR5LOg64K6konSmko87UZ7r3uN98nkiCIOz1EU,10311
+iqm/benchmarks/benchmark_definition.py,sha256=AZkvANrf0_0glbq_P_uo_YqbBU9IZa2gJlMVz6qT6VU,10500
 iqm/benchmarks/benchmark_experiment.py,sha256=ynbsQS92v6soIgkDEdm3ygNO7f82-dhg7qB1l8jvSFM,6614
+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=ugdWwdSpNoCNoqQTRBdSjzMsb9WxFQzKgGFpJmUHChE,12287
-iqm/benchmarks/utils.py,sha256=OoHDBwlr_O9PK90vwidBEFtxJa5CrOSc2suYEPpXLKE,20238
+iqm/benchmarks/readout_mitigation.py,sha256=6lWtDyc0-3WMtVrlwsbC60Ba_xaCDblzdKc34nBbPXg,12327
+iqm/benchmarks/utils.py,sha256=BNbPeNNiFfE72Y-coVjLK3O7y7-j1Ag-l_qyBQsxXRY,20278
 iqm/benchmarks/compressive_gst/__init__.py,sha256=4F_5YxExn4ysGQaEs-WNfm0yiFBxkKtGAYBZFWnRsSk,915
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=qAbAix1PhDwiPPZ82kAHIR6JN-S1oWFdwf6hxVL9ZZk,20679
+iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=pzkqFQQXEZZJmQgwyLo2_eF3rcK3BwXAj5QfY4poczY,21206
 iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=qaF9zDIadPGe9I0l_SC3EfnODZiykzVRxdl4Pu9zZAY,34813
 iqm/benchmarks/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=7Vz15n5D_qEfFaRPkSbEgAbM8aQXBMT0dkRVMIPg7jA,38470
+iqm/benchmarks/entanglement/ghz.py,sha256=qg6mw1RydosKdc2KoPi6M3q0Ek7eMBPIkWOJC2ZDx8M,39446
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=0S6OemnIPmFUamnEPT_lY86Zk_c0a9M2CLYeRJ4Se5c,28056
+iqm/benchmarks/optimization/qscore.py,sha256=pTDRrNI2kkujqb5IoaPTiq9MS8OZd9M8Gv0G2Jn3Ka0,28078
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=PvxnKYSBwJgLOuDcCKB4H_IBzQiLw4RqXAOzquiEPxU,31439
-iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=sy1MDz4U_6JCwc0W85GjC2VHvxUO4fdvHekd2oV4tww,36979
+iqm/benchmarks/quantum_volume/clops.py,sha256=j6BPEj1rKBAHigox7nrvaTLyb4iCrHadBl2d1yiETDA,30956
+iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=8UHDyw1aVXnmo9DpK_qGcfa_NLS148a2YdYNDS4NE78,36870
 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/multi_lmfit.py,sha256=Se1ygR4mXn_2_P82Ch31KBnCmY-g_A9NKzE9Ir8nEvw,3247
-iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=cH-SeOFqsGD6iqTcHTjCMJ-z89mfDjYT_QPsHwJFmU4,37946
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=7vp2BEXSYz3Q7u_42qPKlQtdWPAI-a90tmtlhThWLjg,38809
 iqm/benchmarks/randomized_benchmarking/clifford_rb/__init__.py,sha256=bTDA156LAl7OLGcMec--1nzDrV1XpPRVq3CquTmucgE,677
-iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=uo6cPhoQQ9qAGeZFZG23jxaR88_qKdiqtlBrG_mAGWg,17470
+iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=q8bHcrVr8EjTuLeOdg3RoeoLaZhmieCd09IvH-tSvYs,18038
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
-iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=hTjjitBp0CEkOnvZj_byJ2CzPHiwXaDhxIO8O8dcAj4,26205
+iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=PlHn1J8VPaJF5csNH8jxcifz_MdisOEPU54kU-FYoLY,26920
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=ZekEqI_89nXzGO1vjM-b5Uwwicy59M4fYHXfA-f0MIg,674
-iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=v1UOCVK4_fcOB2VNjMqQB8tp4JwytjdY7RM_lXAtFy0,34463
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=kYlcH0uFdFZmZhkPPEliUTftfDTpefjFdlTgDDo_NXM,33819
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
@@ -33,11 +34,11 @@ mGST/algorithm.py,sha256=jSB9G9uI30zD-IZBJvrvIbdPMXp0elXPxk8F8QeyC3w,26006
 mGST/compatibility.py,sha256=00DsPnNfOtrQcDTvxBDs-0aMhmuXmOIIxl_Ohy-Emkg,8920
 mGST/low_level_jit.py,sha256=z6taafZOmgIRsnKZKPFN6aJ2daRsVjzOeOk_GtmcdwI,27023
 mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
-mGST/qiskit_interface.py,sha256=2XuJ4WFViLsHCTpEZncwsLbRr-cELEYhegTpRPzCcuI,10080
+mGST/qiskit_interface.py,sha256=L4H-4SdhP_bjSFFvpQoF1E7EyGbIJ_CI_y4a7_YEwmU,10102
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
 mGST/reporting/reporting.py,sha256=-XBy3OCJIMOsA8cApwKjhVKBwnjSAoxm-voHNbRWytM,25803
-iqm_benchmarks-1.12.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-1.12.dist-info/METADATA,sha256=zg9mbf09daWGyt2JxN4uc7V8rQQtmewp2QzgkPOBRKE,9074
-iqm_benchmarks-1.12.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-iqm_benchmarks-1.12.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-1.12.dist-info/RECORD,,
+iqm_benchmarks-2.1.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.1.dist-info/METADATA,sha256=xjuOpIJTAGGmJaC7brTnB0jWJe3wcxzqDb-jN7lc95k,9073
+iqm_benchmarks-2.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+iqm_benchmarks-2.1.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.1.dist-info/RECORD,,

mGST/qiskit_interface.py

@@ -5,10 +5,10 @@ Bridge between mGST and Qiskit
 import random
 
 import numpy as np
-from qiskit import QuantumCircuit
 from qiskit.circuit.library import IGate
 from qiskit.quantum_info import Operator
 
+from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from mGST import additional_fns, algorithm, low_level_jit
 from mGST.compatibility import arrays_to_pygsti_model
 from mGST.reporting.reporting import gauge_opt, quick_report