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

iqm/benchmarks/benchmark.py

@@ -51,6 +51,7 @@ class BenchmarkBase(ABC):
         self.shots = self.configuration.shots
         self.calset_id = self.configuration.calset_id
         self.max_gates_per_batch = self.configuration.max_gates_per_batch
+        self.max_circuits_per_batch = self.configuration.max_circuits_per_batch
 
         self.routing_method = self.configuration.routing_method
         self.physical_layout = self.configuration.physical_layout
@@ -92,6 +93,8 @@ class BenchmarkConfigurationBase(BaseModel):
                 * Default for all benchmarks is 2**8.
         max_gates_per_batch (Optional[int]): the maximum number of gates per circuit batch.
                 * Default for all benchmarks is None.
+        max_circuits_per_batch (Optional[int]): the maximum number of circuits per batch.
+                * Default for all benchmarks is None.
         calset_id (Optional[str]): the calibration ID to use in circuit execution.
                 * Default for all benchmarks is None (uses last available calibration ID).
         routing_method (Literal["basic", "lookahead", "stochastic", "sabre", "none"]): the Qiskit routing method to use in transpilation.
@@ -100,13 +103,14 @@ class BenchmarkConfigurationBase(BaseModel):
                 - "fixed": physical layout is constrained during transpilation to the selected initial physical qubits.
                 - "batching": physical layout is allowed to use any other physical qubits, and circuits are batched according to final measured qubits.
                 * Default for all benchmarks is "fixed".
-        use_DD (bool): Boolean flag determining if dynamical decoupling is enabled during circuit execution
+        use_dd (bool): Boolean flag determining whether to enable dynamical decoupling during circuit execution.
             * Default: False
     """
 
     benchmark: Type[BenchmarkBase]
     shots: int = 2**8
     max_gates_per_batch: Optional[int] = None
+    max_circuits_per_batch: Optional[int] = None
     calset_id: Optional[str] = None
     routing_method: Literal["basic", "lookahead", "stochastic", "sabre", "none"] = "sabre"
     physical_layout: Literal["fixed", "batching"] = "fixed"

iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -81,10 +81,7 @@ class CompressiveGST(Benchmark):
         if configuration.opt_method not in ["GD", "SFN", "auto"]:
             raise ValueError("Invalid optimization method, valid options are: GD, SFN, auto")
         if configuration.opt_method == "auto":
-            if (self.num_qubits == 2 and configuration.rank > 2) or self.num_qubits > 2:
-                self.opt_method = "GD"
-            else:
-                self.opt_method = "SFN"
+            self.opt_method = "GD"  # Currently the fastest method in all cases
         else:
             self.opt_method = configuration.opt_method
 
@@ -160,17 +157,23 @@ class CompressiveGST(Benchmark):
                     "Qubit layouts can't overlap when parallel_execution is enabled, please choose non-overlapping layouts."
                 )
             raw_qc_list_parallel = []
+            if "move" in self.backend.operation_names:
+                backend_qubits = np.arange(1, self.backend.num_qubits)
+                qubit_layouts = [[q - 1 for q in layout] for layout in self.qubit_layouts]
+            else:
+                backend_qubits = np.arange(self.backend.num_qubits)
+                qubit_layouts = self.qubit_layouts
             for circ in raw_qc_list:
-                circ_parallel = QuantumCircuit(self.backend.num_qubits, len(set(all_qubits)))
+                circ_parallel = QuantumCircuit(len(backend_qubits), len(set(all_qubits)))
                 clbits = np.arange(self.num_qubits)
-                for qubit_layout in self.qubit_layouts:
+                for qubit_layout in qubit_layouts:
                     circ_parallel.compose(circ, qubits=qubit_layout, clbits=clbits, inplace=True)
                     clbits += self.num_qubits
                 raw_qc_list_parallel.append(circ_parallel)
             transpiled_qc_list, _ = perform_backend_transpilation(
                 raw_qc_list_parallel,
                 self.backend,
-                qubits=np.arange(self.backend.num_qubits),
+                qubits=backend_qubits,
                 coupling_map=self.backend.coupling_map,
                 qiskit_optim_level=0,
                 optimize_sqg=False,
@@ -239,6 +242,7 @@ class CompressiveGST(Benchmark):
                 self.configuration.shots,
                 self.calset_id,
                 max_gates_per_batch=self.configuration.max_gates_per_batch,
+                max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
             # Retrieve
@@ -255,6 +259,7 @@ class CompressiveGST(Benchmark):
                     self.configuration.shots,
                     self.calset_id,
                     max_gates_per_batch=self.configuration.max_gates_per_batch,
+                    max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 )
             # Retrieve all
             qcvv_logger.info(f"Now executing the corresponding circuit batch")
@@ -386,7 +391,7 @@ def parse_gate_set(
         gate_set: List[QuantumCircuit]
             A list of gates defined as quantum circuit objects
         gate_labels_dict: Dict[str, Dict[int, str]]
-            The names of gates, i.e. "Rx(pi/2)" for a pi/2 rotation around the x-axis.
+            The names of gates, i.e. "Rx_pi_2" for a pi/2 rotation around the x-axis.
         num_gates: int
             The number of gates in the gate set
 
@@ -445,7 +450,7 @@ def create_predefined_gate_set(
         gates: List[QuantumCircuit]
             The gate set as a list of circuits
         gate_labels_dict: Dict[str, Dict[int, str]]
-            The names of gates, i.e. "Rx(pi/2)" for a pi/2 rotation around the x-axis.
+            The names of gates, i.e. "Rx_pi_2" for a pi/2 rotation around the x-axis.
         num_gates: int
             The number of gates in the gate set
 
@@ -458,7 +463,7 @@ def create_predefined_gate_set(
         gate_qubits = [[0], [0], [0]]
         for i, gate in enumerate(gate_list):
             gates[i].append(gate, gate_qubits[i])
-        gate_labels = ["Idle", "Rx(pi/2)", "Ry(pi/2)"]
+        gate_labels = ["Idle", "Rx_pi_2", "Ry_pi_2"]
     elif gate_set == "2QXYCZ":
         gate_qubits = [[0], [1], [0], [1], [0, 1]]
         gates = [QuantumCircuit(num_qubits, 0) for _ in range(5)]
@@ -467,7 +472,7 @@ def create_predefined_gate_set(
         gates[2].append(RGate(0.5 * np.pi, np.pi / 2), [0])
         gates[3].append(RGate(0.5 * np.pi, np.pi / 2), [1])
         gates[4].append(CZGate(), [0, 1])
-        gate_labels = ["Rx(pi/2)", "Rx(pi/2)", "Ry(pi/2)", "Ry(pi/2)", "CZ"]
+        gate_labels = ["Rx_pi_2", "Rx_pi_2", "Ry_pi_2", "Ry_pi_2", "cz"]
     elif gate_set == "2QXYCZ_extended":
         gate_qubits = [[0], [1], [0], [1], [0, 1], [0, 1], [0, 1], [0, 1], [0, 1]]
         gates = [QuantumCircuit(num_qubits, 0) for _ in range(9)]
@@ -485,14 +490,14 @@ def create_predefined_gate_set(
         gates[7].append(RGate(0.5 * np.pi, np.pi / 2), [1])
         gates[8].append(CZGate(), [[0], [1]])
         gate_labels = [
-            "Rx(pi/2)",
-            "Rx(pi/2)",
-            "Ry(pi/2)",
-            "Ry(pi/2)",
-            "Rx(pi/2)-Rx(pi/2)",
-            "Rx(pi/2)-Ry(pi/2)",
-            "Ry(pi/2)-Rx(pi/2)",
-            "Ry(pi/2)-Ry(pi/2)",
+            "Rx_pi_2",
+            "Rx_pi_2",
+            "Ry_pi_2",
+            "Ry_pi_2",
+            "Rx_pi_2-Rx_pi_2",
+            "Rx_pi_2-Ry_pi_2",
+            "Ry_pi_2-Rx_pi_2",
+            "Ry_pi_2-Ry_pi_2",
             "CZ",
         ]
     elif gate_set == "3QXYCZ":
@@ -510,7 +515,7 @@ def create_predefined_gate_set(
         gate_qubits = [[0], [1], [2], [0], [1], [2], [0, 1], [0, 2]]
         for i, gate in enumerate(gate_list):
             gates[i].append(gate, gate_qubits[i])
-        gate_labels = ["Rx(pi/2)", "Rx(pi/2)", "Rx(pi/2)", "Ry(pi/2)", "Ry(pi/2)", "Ry(pi/2)", "CZ", "CZ"]
+        gate_labels = ["Rx_pi_2", "Rx_pi_2", "Rx_pi_2", "Ry_pi_2", "Ry_pi_2", "Ry_pi_2", "cz", "cz"]
     else:
         raise ValueError(
             f"Invalid gate set, choose among 1QXYI, 2QXYCZ, 2QXYCZ_extended,"
@@ -526,6 +531,6 @@ def create_predefined_gate_set(
         iqm_qubits = [f"QB{q + 1}" for q in qubit_layout]
         gate_qubits_iqm = [(iqm_qubits[q] for q in qubits) for qubits in gate_qubits]
         for key, value in layout_label_dict.items():
-            layout_label_dict[key] = value + ":" + "-".join(gate_qubits_iqm[key])
+            layout_label_dict[key] = value + ":" + "__".join(gate_qubits_iqm[key])
         gate_label_dict.update({BenchmarkObservationIdentifier(qubit_layout).string_identifier: layout_label_dict})
     return gates, gate_label_dict, len(gates)

iqm/benchmarks/compressive_gst/gst_analysis.py

@@ -2,6 +2,7 @@
 Data analysis code for compressive gate set tomography
 """
 
+import ast
 from itertools import product
 from time import perf_counter
 from typing import Any, List, Tuple, Union
@@ -218,16 +219,16 @@ def generate_non_gate_results(
         percentiles_o_low, percentiles_o_high = np.nanpercentile(df_o_array, [2.5, 97.5], axis=0)
         df_o_final = DataFrame(
             {
-                f"Mean TVD: estimate - data": reporting.number_to_str(
+                f"mean_total_variation_distance_estimate_data": reporting.number_to_str(
                     df_o.values[0, 1].copy(), [percentiles_o_high[0, 1], percentiles_o_low[0, 1]], precision=5
                 ),
-                f"Mean TVD: target - data": reporting.number_to_str(
+                f"mean_total_variation_distance_target_data": reporting.number_to_str(
                     df_o.values[0, 2].copy(), [percentiles_o_high[0, 2], percentiles_o_low[0, 2]], precision=5
                 ),
-                f"POVM - diamond dist.": reporting.number_to_str(
+                f"povm_diamond_distance": reporting.number_to_str(
                     df_o.values[0, 3].copy(), [percentiles_o_high[0, 3], percentiles_o_low[0, 3]], precision=5
                 ),
-                f"State - trace dist.": reporting.number_to_str(
+                f"state_trace_distance": reporting.number_to_str(
                     df_o.values[0, 4].copy(), [percentiles_o_high[0, 4], percentiles_o_low[0, 4]], precision=5
                 ),
             },
@@ -236,10 +237,10 @@ def generate_non_gate_results(
     else:
         df_o_final = DataFrame(
             {
-                f"Mean TVD: estimate - data": reporting.number_to_str(df_o.values[0, 1].copy(), precision=5),
-                f"Mean TVD: target - data": reporting.number_to_str(df_o.values[0, 2].copy(), precision=5),
-                f"POVM - diamond dist.": reporting.number_to_str(df_o.values[0, 3].copy(), precision=5),
-                f"State - trace dist.": reporting.number_to_str(df_o.values[0, 4].copy(), precision=5),
+                f"mean_total_variation_distance_estimate_data": reporting.number_to_str(df_o.values[0, 1].copy(), precision=5),
+                f"mean_total_variation_distance_target_data": reporting.number_to_str(df_o.values[0, 2].copy(), precision=5),
+                f"povm_diamond_distance": reporting.number_to_str(df_o.values[0, 3].copy(), precision=5),
+                f"state_trace_distance": reporting.number_to_str(df_o.values[0, 4].copy(), precision=5),
             },
             index=[""],
         )
@@ -290,13 +291,13 @@ def generate_unit_rank_gate_results(
 
         df_g_final = DataFrame(
             {
-                r"Avg. gate fidelity": [
+                r"average_gate_fidelity": [
                     reporting.number_to_str(
                         df_g.values[i, 0], [percentiles_g_high[i, 0], percentiles_g_low[i, 0]], precision=5
                     )
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
-                r"Diamond distance": [
+                r"diamond_distance": [
                     reporting.number_to_str(
                         df_g.values[i, 1], [percentiles_g_high[i, 1], percentiles_g_low[i, 1]], precision=5
                     )
@@ -338,10 +339,10 @@ def generate_unit_rank_gate_results(
     else:
         df_g_final = DataFrame(
             {
-                "Avg. gate fidelity": [
+                "average_gate_fidelity": [
                     reporting.number_to_str(df_g.values[i, 0], precision=5) for i in range(dataset.attrs["num_gates"])
                 ],
-                "Diamond distance": [
+                "diamond_distance": [
                     reporting.number_to_str(df_g.values[i, 1], precision=5) for i in range(dataset.attrs["num_gates"])
                 ],
             }
@@ -442,19 +443,19 @@ def generate_gate_results(
 
         df_g_final = DataFrame(
             {
-                r"Avg. gate fidelity": [
+                r"average_gate_fidelity": [
                     reporting.number_to_str(
                         df_g.values[i, 0], [percentiles_g_high[i, 0], percentiles_g_low[i, 0]], precision=5
                     )
                     for i in range(dataset.attrs["num_gates"])
                 ],
-                r"Diamond distance": [
+                r"diamond_distance": [
                     reporting.number_to_str(
                         df_g.values[i, 1], [percentiles_g_high[i, 1], percentiles_g_low[i, 1]], precision=5
                     )
                     for i in range(dataset.attrs["num_gates"])
                 ],
-                r"Unitarity": [
+                r"unitarity": [
                     reporting.number_to_str(
                         reporting.unitarities(X_opt_pp)[i],
                         [percentiles_u_high[i], percentiles_u_low[i]],
@@ -468,15 +469,15 @@ def generate_gate_results(
     else:
         df_g_final = DataFrame(
             {
-                "Avg. gate fidelity": [
+                "average_gate_fidelity": [
                     reporting.number_to_str(df_g.values[i, 0].copy(), precision=5)
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
-                "Diamond distance": [
+                "diamond_distance": [
                     reporting.number_to_str(df_g.values[i, 1].copy(), precision=5)
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
-                "Unitarity": [
+                "unitarity": [
                     reporting.number_to_str(reporting.unitarities(X_opt_pp)[i], precision=5)
                     for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
@@ -574,11 +575,12 @@ def pandas_results_to_observations(
     """
     observation_list: list[BenchmarkObservation] = []
     err = dataset.attrs["bootstrap_samples"] > 0
+    qubits = "__".join([f"QB{i+1}" for i in ast.literal_eval(identifier.string_identifier)])
     for idx, gate_label in enumerate(dataset.attrs["gate_labels"][identifier.string_identifier].values()):
         observation_list.extend(
             [
                 BenchmarkObservation(
-                    name=f"{name} - {gate_label}",
+                    name=f"{name}_{gate_label}:crosstalk_components={qubits}",
                     identifier=identifier,
                     value=result_str_to_floats(df_g[name].iloc[idx], err)[0],
                     uncertainty=result_str_to_floats(df_g[name].iloc[idx], err)[1],
@@ -754,6 +756,7 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     dataset = run.dataset
     pdim = dataset.attrs["pdim"]
     plots = {}
+    observations = []
     for i, qubit_layout in enumerate(dataset.attrs["qubit_layouts"]):
         identifier = BenchmarkObservationIdentifier(qubit_layout).string_identifier
 
@@ -820,8 +823,10 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         plots[f"layout_{qubit_layout}_gate_metrics"] = fig_g
         plots[f"layout_{qubit_layout}_other_metrics"] = fig_o
 
-        observation_list = pandas_results_to_observations(
-            dataset, df_g_final, df_o_final, BenchmarkObservationIdentifier(qubit_layout)
+        observations.extend(
+            pandas_results_to_observations(
+                dataset, df_g_final, df_o_final, BenchmarkObservationIdentifier(qubit_layout)
+            )
         )
 
         dataset.attrs["results_layout_" + identifier].update(
@@ -865,4 +870,4 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         )
         plt.close("all")
 
-    return BenchmarkAnalysisResult(dataset=dataset, observations=observation_list, plots=plots)
+    return BenchmarkAnalysisResult(dataset=dataset, observations=observations, plots=plots)

iqm/benchmarks/entanglement/ghz.py

@@ -851,6 +851,7 @@ class GHZBenchmark(Benchmark):
                 self.shots,
                 self.calset_id,
                 max_gates_per_batch=self.max_gates_per_batch,
+                max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                 circuit_compilation_options=self.circuit_compilation_options,
             )
 

iqm/benchmarks/optimization/qscore.py

@@ -475,23 +475,24 @@ def qscore_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             qcvv_logger.info(
                 f"Q-Score = {num_nodes} failed with approximation ratio (Beta) {approximation_ratio:.4f} < 0.2; Avg MaxCut size: {np.mean(cut_sizes_list):.4f}"
             )
+        qubit_indices = dataset.attrs[num_nodes]["qubit_set"][0]
         observations.extend(
             [
                 BenchmarkObservation(
                     name="mean_approximation_ratio",
                     value=approximation_ratio,
                     uncertainty=std_of_approximation_ratio,
-                    identifier=BenchmarkObservationIdentifier(num_nodes),
+                    identifier=BenchmarkObservationIdentifier(qubit_indices),
                 ),
                 BenchmarkObservation(
                     name="is_succesful",
                     value=str(success),
-                    identifier=BenchmarkObservationIdentifier(num_nodes),
+                    identifier=BenchmarkObservationIdentifier(qubit_indices),
                 ),
                 BenchmarkObservation(
                     name="Qscore_result",
                     value=qscore if success else 1,
-                    identifier=BenchmarkObservationIdentifier(num_nodes),
+                    identifier=BenchmarkObservationIdentifier(qubit_indices),
                 ),
             ]
         )
@@ -751,7 +752,7 @@ class QScoreBenchmark(Benchmark):
         else:
             nqubits = self.backend.num_qubits
 
-        if self.custom_qubits_array is not None:
+        if self.choose_qubits_routine == "custom":
             if self.use_virtual_node:
                 node_numbers = [len(qubit_layout) + 1 for qubit_layout in self.custom_qubits_array]
             else:
@@ -765,7 +766,7 @@ class QScoreBenchmark(Benchmark):
                     max_num_nodes = nqubits
             else:
                 max_num_nodes = self.max_num_nodes
-            node_numbers = range(self.min_num_nodes, max_num_nodes + 1)
+            node_numbers = list(range(self.min_num_nodes, max_num_nodes + 1))
 
         dataset.attrs.update({"max_num_nodes": node_numbers[-1]})
         dataset.attrs.update({"node_numbers": node_numbers})
@@ -881,6 +882,7 @@ class QScoreBenchmark(Benchmark):
                         self.shots,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                     qc_transpiled_list.append(transpiled_qc)

iqm/benchmarks/quantum_volume/clops.py

@@ -565,6 +565,7 @@ class CLOPSBenchmark(Benchmark):
             self.num_shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            max_circuits_per_batch=self.configuration.max_circuits_per_batch,
             circuit_compilation_options=self.circuit_compilation_options,
         )
 

iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -26,7 +26,7 @@ from mthree.classes import QuasiCollection
 from mthree.utils import expval
 import numpy as np
 from qiskit.circuit.library import QuantumVolume
-from qiskit_aer import Aer
+from qiskit_aer import StatevectorSimulator
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
@@ -119,7 +119,7 @@ def get_ideal_heavy_outputs(
     """
     simulable_circuits = deepcopy(qc_list)
     ideal_heavy_outputs: List[Dict[str, float]] = []
-    ideal_simulator = Aer.get_backend("statevector_simulator")
+    ideal_simulator = StatevectorSimulator()
 
     # Separate according to sorted indices
     circuit_batches = {
@@ -698,6 +698,7 @@ class QuantumVolumeBenchmark(Benchmark):
             self.shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            max_circuits_per_batch=self.configuration.max_circuits_per_batch,
             circuit_compilation_options=self.circuit_compilation_options,
         )
         # qcvv_logger.info(

iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -125,13 +125,18 @@ def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         fidelity = rb_fit_results.params["fidelity_per_clifford"]
 
         processed_results = {
-            "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
+            "average_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
         }
 
         if len(qubits) == 1:
             fidelity_native = rb_fit_results.params["fidelity_per_native_sqg"]
             processed_results.update(
-                {"avg_native_gate_fidelity": {"value": fidelity_native.value, "uncertainty": fidelity_native.stderr}}
+                {
+                    "average_native_gate_fidelity": {
+                        "value": fidelity_native.value,
+                        "uncertainty": fidelity_native.stderr,
+                    }
+                }
             )
 
         dataset.attrs[qubits_idx].update(
@@ -140,8 +145,8 @@ def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 "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,
+                "average_fidelities_nominal_values": average_fidelities,
+                "average_fidelities_stderr": stddevs_from_mean,
                 "fitting_method": str(rb_fit_results.method),
                 "num_function_evals": int(rb_fit_results.nfev),
                 "data_points": int(rb_fit_results.ndata),
@@ -294,6 +299,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         self.shots,
                         self.calset_id,
                         self.max_gates_per_batch,
+                        self.configuration.max_circuits_per_batch,
                     )
                 )
                 qcvv_logger.info(f"Job for sequence length {seq_length} submitted successfully!")
@@ -353,6 +359,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         self.backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )

iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -173,14 +173,14 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             )
 
             processed_results[rb_type] = {
-                "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
+                "average_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
             }
 
             if len(qubits) == 1 and rb_type == "clifford":
                 fidelity_native = rb_fit_results.params["fidelity_per_native_sqg"]
                 processed_results[rb_type].update(
                     {
-                        "avg_gate_fidelity_native": {
+                        "average_gate_fidelity_native": {
                             "value": fidelity_native.value,
                             "uncertainty": fidelity_native.stderr,
                         }
@@ -190,7 +190,7 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 fidelity_native_sqg = rb_fit_results.params["fidelity_per_native_sqg"]
                 processed_results[rb_type].update(
                     {
-                        "avg_gate_fidelity_native_sqg": {
+                        "average_gate_fidelity_native_sqg": {
                             "value": fidelity_native_sqg.value,
                             "uncertainty": fidelity_native_sqg.stderr,
                         }
@@ -200,7 +200,7 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             observations.extend(
                 [
                     BenchmarkObservation(
-                        name=f"{key}_{rb_type}" if "native" not in key else f"{key}",
+                        name=f"{key}_{interleaved_gate}" if "native" not in key else f"{key}",
                         identifier=BenchmarkObservationIdentifier(qubits),
                         value=values["value"],
                         uncertainty=values["uncertainty"],
@@ -216,8 +216,8 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                         "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,
+                        "average_fidelities_nominal_values": average_fidelities,
+                        "average_fidelities_stderr": stddevs_from_mean,
                         "fitting_method": str(rb_fit_results.method),
                         "num_function_evals": int(rb_fit_results.nfev),
                         "data_points": int(rb_fit_results.ndata),
@@ -407,6 +407,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         self.shots,
                         self.calset_id,
                         self.max_gates_per_batch,
+                        self.configuration.max_circuits_per_batch,
                     )
                 )
                 all_rb_jobs["interleaved"].append(
@@ -418,6 +419,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         self.shots,
                         self.calset_id,
                         self.max_gates_per_batch,
+                        self.configuration.max_circuits_per_batch,
                     )
                 )
                 qcvv_logger.info(f"Both jobs for sequence length {seq_length} submitted successfully!")
@@ -513,6 +515,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )
@@ -524,6 +527,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        max_circuits_per_batch=self.configuration.max_circuits_per_batch,
                         circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -522,7 +522,7 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         fidelity = rb_fit_results.params["fidelity_mrb"]
 
         processed_results = {
-            "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
+            "average_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
         }
 
         dataset.attrs[qubits_idx].update(
@@ -531,8 +531,8 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 "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,
+                "average_polarization_nominal_values": average_polarizations,
+                "average_polatization_stderr": stddevs_from_mean,
                 "fitting_method": str(rb_fit_results.method),
                 "num_function_evals": int(rb_fit_results.nfev),
                 "data_points": int(rb_fit_results.ndata),
@@ -662,6 +662,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
             self.shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            max_circuits_per_batch=self.configuration.max_circuits_per_batch,
             circuit_compilation_options=self.circuit_compilation_options,
         )
         mrb_submit_results = {

iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py

@@ -439,6 +439,7 @@ def submit_parallel_rb_job(
     shots: int,
     calset_id: Optional[str],
     max_gates_per_batch: Optional[str],
+    max_circuits_per_batch: Optional[int],
 ) -> Dict[str, Any]:
     """Submit fixed-depth parallel MRB jobs for execution in the specified IQMBackend
     Args:
@@ -449,6 +450,7 @@ def submit_parallel_rb_job(
         shots (int): the number of shots to submit the job
         calset_id (Optional[str]): the calibration identifier
         max_gates_per_batch (Optional[str]): the maximum number of gates per batch to submit the job
+        max_circuits_per_batch (Optional[int]): the maximum number of circuits per batch to submit the job.
     Returns:
         Dict with qubit layout, submitted job objects, type (vanilla/DD) and submission time
     """
@@ -456,7 +458,12 @@ def submit_parallel_rb_job(
     # Send to execute on backend
     # pylint: disable=unbalanced-tuple-unpacking
     execution_jobs, time_submit = submit_execute(
-        sorted_transpiled_circuit_dicts, backend_arg, shots, calset_id, max_gates_per_batch=max_gates_per_batch
+        sorted_transpiled_circuit_dicts,
+        backend_arg,
+        shots,
+        calset_id,
+        max_gates_per_batch=max_gates_per_batch,
+        max_circuits_per_batch=max_circuits_per_batch,
     )
     rb_submit_results = {
         "qubits": qubits_array,
@@ -474,6 +481,7 @@ def submit_sequential_rb_jobs(
     backend_arg: str | IQMBackendBase,
     calset_id: Optional[str] = None,
     max_gates_per_batch: Optional[int] = None,
+    max_circuits_per_batch: Optional[int] = None,
     circuit_compilation_options: Optional[CircuitCompilationOptions] = None,
 ) -> List[Dict[str, Any]]:
     """Submit sequential RB jobs for execution in the specified IQMBackend
@@ -484,6 +492,7 @@ def submit_sequential_rb_jobs(
         backend_arg (IQMBackendBase): the IQM backend to submit the job
         calset_id (Optional[str]): the calibration identifier
         max_gates_per_batch (Optional[int]): the maximum number of gates per batch
+        max_circuits_per_batch (Optional[int]): the maximum number of circuits per batch
         circuit_compilation_options (Optional[CircuitCompilationOptions]): Compilation options passed to submit_execute
     Returns:
         Dict with qubit layout, submitted job objects, type (vanilla/DD) and submission time
@@ -504,6 +513,7 @@ def submit_sequential_rb_jobs(
             shots,
             calset_id,
             max_gates_per_batch,
+            max_circuits_per_batch=max_circuits_per_batch,
             circuit_compilation_options=circuit_compilation_options,
         )
         rb_submit_results[depth] = {
@@ -627,11 +637,11 @@ def plot_rb_decay(
                 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"]
+                str(q): dataset.attrs[q_idx]["average_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"]
+                str(q): dataset.attrs[q_idx]["average_polatization_stderr"]
                 for q_idx, q in enumerate(qubits_array, qubits_index)
             }
         else:  # identifier == "clifford"
@@ -643,28 +653,28 @@ def plot_rb_decay(
                 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"]
+                str(q): dataset.attrs[q_idx]["average_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"]
+                str(q): dataset.attrs[q_idx]["average_fidelities_stderr"]
                 for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             fidelity_native1q_value[identifier] = {
-                str(q): observations[q_idx]["avg_native_gate_fidelity"]["value"] if len(q) == 1 else np.nan
+                str(q): observations[q_idx]["average_native_gate_fidelity"]["value"] if len(q) == 1 else np.nan
                 for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             fidelity_native1q_stderr[identifier] = {
-                str(q): observations[q_idx]["avg_native_gate_fidelity"]["uncertainty"] if len(q) == 1 else np.nan
+                str(q): observations[q_idx]["average_native_gate_fidelity"]["uncertainty"] if len(q) == 1 else np.nan
                 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"]
+            str(q): observations[q_idx]["average_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"]
+            str(q): observations[q_idx]["average_gate_fidelity"]["uncertainty"]
             for q_idx, q in enumerate(qubits_array, qubits_index)
         }
         decay_rate[identifier] = {
@@ -689,19 +699,19 @@ def plot_rb_decay(
                 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"]
+                str(q): dataset.attrs[q_idx][rb_type]["average_fidelities_nominal_values"]
                 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"]
+                str(q): dataset.attrs[q_idx][rb_type]["average_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"]
+                str(q): observations[q_idx][rb_type]["average_gate_fidelity"]["value"]
                 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"]
+                str(q): observations[q_idx][rb_type]["average_gate_fidelity"]["uncertainty"]
                 for q_idx, q in enumerate(qubits_array, qubits_index)
             }
             decay_rate[rb_type] = {

iqm/benchmarks/utils.py

@@ -503,6 +503,7 @@ def submit_execute(
     shots: int,
     calset_id: Optional[str] = None,
     max_gates_per_batch: Optional[int] = None,
+    max_circuits_per_batch: Optional[int] = None,
     circuit_compilation_options: Optional[CircuitCompilationOptions] = None,
 ) -> List[IQMJob]:
     """Submit for execute a list of quantum circuits on the specified Backend.
@@ -511,10 +512,15 @@ def submit_execute(
         sorted_transpiled_qc_list (Dict[Tuple, List[QuantumCircuit]]): the list of quantum circuits to be executed.
         backend (IQMBackendBase): the backend to execute the circuits on.
         shots (int): the number of shots per circuit.
-        calset_id (Optional[str]): the calibration set ID, uses the latest one if None.
-        max_gates_per_batch (int): the maximum number of gates per batch sent to the backend, used to make manageable batches.
+        calset_id (Optional[str]): the calibration set ID.
+            * Default is None: uses the latest calibration ID.
+        max_gates_per_batch (Optional[int]): the maximum number of gates per batch sent to the backend, used to make manageable batches.
+            * Default is None.
+        max_circuits_per_batch (Optional[int]): the maximum number of circuits per batch sent to the backend, used to make manageable batches.
+            * Default is None.
         circuit_compilation_options (CircuitCompilationOptions): Ability to pass a compilation options object,
             enabling execution with dynamical decoupling, among other options - see qiskit-iqm documentation.
+            * Default is None.
     Returns:
         List[IQMJob]: the IQMJob objects of the executed circuits.
 
@@ -530,23 +536,41 @@ def submit_execute(
             f"Submitting batch with {len(sorted_transpiled_qc_list[k])} circuits corresponding to qubits {list(k)}"
         )
         # Divide into batches according to maximum gate count per batch
-        if max_gates_per_batch is None:
+        if max_gates_per_batch is None and max_circuits_per_batch is None:
             jobs = backend.run(sorted_transpiled_qc_list[k], shots=shots, calibration_set_id=calset_id)
             final_jobs.append(jobs)
+
         else:
-            # Calculate average gate count per quantum circuit
-            avg_gates_per_qc = sum(sum(qc.count_ops().values()) for qc in sorted_transpiled_qc_list[k]) / len(
-                sorted_transpiled_qc_list[k]
-            )
-            final_batch_jobs = []
-            for index, qc_batch in enumerate(
-                chunked(
-                    sorted_transpiled_qc_list[k],
-                    max(1, floor(max_gates_per_batch / avg_gates_per_qc)),
+            if max_gates_per_batch is None and max_circuits_per_batch is not None:
+                restriction = "max_circuits_per_batch"
+                batching_size = max_circuits_per_batch
+
+            elif max_circuits_per_batch is None and max_gates_per_batch is not None:
+                restriction = "max_gates_per_batch"
+                # Calculate average gate count per quantum circuit
+                avg_gates_per_qc = sum(sum(qc.count_ops().values()) for qc in sorted_transpiled_qc_list[k]) / len(
+                    sorted_transpiled_qc_list[k]
+                )
+                batching_size = max(1, floor(max_gates_per_batch / avg_gates_per_qc))
+
+            else:  # Both are not None - select the one rendering the smallest batches.
+                # Calculate average gate count per quantum circuit
+                avg_gates_per_qc = sum(sum(qc.count_ops().values()) for qc in sorted_transpiled_qc_list[k]) / len(
+                    sorted_transpiled_qc_list[k]
+                )
+                qcvv_logger.warning(
+                    "Both max_gates_per_batch and max_circuits_per_batch are not None. Selecting the one giving the smallest batches."
                 )
-            ):
+                batching_size = min(max_circuits_per_batch, max(1, floor(max_gates_per_batch / avg_gates_per_qc)))  # type: ignore
+                if batching_size == max_circuits_per_batch:
+                    restriction = "max_circuits_per_batch"
+                else:
+                    restriction = "max_gates_per_batch"
+
+            final_batch_jobs = []
+            for index, qc_batch in enumerate(chunked(sorted_transpiled_qc_list[k], batching_size)):
                 qcvv_logger.info(
-                    f"max_gates_per_batch restriction: submitting subbatch #{index+1} with {len(qc_batch)} circuits corresponding to qubits {list(k)}"
+                    f"{restriction} restriction: submitting subbatch #{index + 1} with {len(qc_batch)} circuits corresponding to qubits {list(k)}"
                 )
                 batch_jobs = backend.run(
                     qc_batch,

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.24
+Version: 2.26
 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
@@ -50,6 +50,7 @@ Provides-Extra: docs
 Requires-Dist: sphinx==7.2.6; extra == "docs"
 Requires-Dist: sphinx-book-theme==1.1.2; extra == "docs"
 Requires-Dist: myst-parser<5,>=4.0.0; extra == "docs"
+Dynamic: license-file
 
 # IQM Benchmarks
 
@@ -194,7 +195,7 @@ EXAMPLE_MRB = MirrorRBConfiguration(
 )
 
 EXAMPLE_QV = QuantumVolumeConfiguration(
-    num_circuits=500,
+    num_circuits=800,
     shots=2**8,
     calset_id=None,
     num_sigmas=2,
@@ -204,7 +205,8 @@ EXAMPLE_QV = QuantumVolumeConfiguration(
     optimize_sqg=True,
     routing_method="sabre",
     physical_layout="fixed",
-    max_gates_per_batch=60_000,
+    max_circuits_per_batch=500,
+    max_gates_per_batch=60_000, # Will be used if it renders a smaller max batch size than max_circuits_per_batch
     rem=True,
     mit_shots=1_000,
 )

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

@@ -1,31 +1,32 @@
 iqm/benchmarks/__init__.py,sha256=8SRHlADqZjlP8PtbKTMvu-ejpcEZkW8cPmgW8GVKJg8,2638
-iqm/benchmarks/benchmark.py,sha256=F0WdGFpYGVWMeyKmScfM7b7jvuS8P8UArB3_JwUKJrY,4694
+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=ZwAGYIhPe4Ij2Ds8drd_0eHwpdBj1L7rm1d33oqN4L8,31928
+iqm/benchmarks/utils.py,sha256=_1iLsc-azCE4ucHlD1LLRPdTryUKaMs8r75q3njRugE,33451
 iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=D54hnaxxOIyD3ygUMKyxfRMwfUXfK4O5UdzdgscwkHA,25291
-iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=2qY46e-euAcdThcits_Wo7hGb0m69mDZY0d1Qv_wq4M,36104
+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=HqvdRaiwM879QUrFnULcprdZ-frr1-i4bQ1U8jKjIn0,40993
+iqm/benchmarks/entanglement/ghz.py,sha256=jSPcdFf1Xsq09EJXKCVHzNXjQIdAoDg859279wKGjaQ,41075
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=Ns3Sik90YQ_Cry1I5tY-QQWcLukpyipAfVb1Lmkkd7M,37957
+iqm/benchmarks/optimization/qscore.py,sha256=ufkIKuh0XtiSVn-3Deca-7Ky1cXZ1CxCXMN-j-Lhevw,38132
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=kMzofZEtB_SmbGWcB9LWGbG96I342Im3xIWDt9nTqUY,31393
-iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=2nNlZeR2VhtKkc3gpCkaR24NE23T0aQXNrepTlUL-8I,36549
+iqm/benchmarks/quantum_volume/clops.py,sha256=xlziaxjhJUNyHjBCMzMLeJ9PcFNBtDO7urKvCTBb4sI,31471
+iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=4ll3R8AX-BA599TEaMBzE2rJtAzHLtCkq8CaSkJfA0Y,36626
 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=SKpNukg_vOEVKpd_MAGj4xTFK5FpFJEwx2Zr_2uSUAQ,41867
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=pe9wSFvQ6Vh7rWZNZalIKOeaHoXc8iT4pkvrcLmY75g,42352
 iqm/benchmarks/randomized_benchmarking/clifford_rb/__init__.py,sha256=bTDA156LAl7OLGcMec--1nzDrV1XpPRVq3CquTmucgE,677
-iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=H-nfuQaIUWcxYeW61iEc79eZwuAFbDvozTVT0xC0HRw,18403
+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=CsnajadrpxQOqEvX8PpMGB5_9_g6W1IT4aaQRYa1Z08,28128
+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=KNIfu3ucb-oxAwOIl5zarRUeWM1SPmiVEQFo6970oUU,34904
+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
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
@@ -36,8 +37,7 @@ mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
 mGST/qiskit_interface.py,sha256=ajx6Zn5FnrX_T7tMP8xnBLyG4c2ddFRm0Fu2_3r1t30,10118
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
 mGST/reporting/reporting.py,sha256=B8NWfpZrrSmyH7lwZxd0EbZMYLsAGK1YsHRB4D5qXH4,26002
-iqm_benchmarks-2.24.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-2.24.dist-info/METADATA,sha256=Ol8LfGuAQo3-5lUfrid79VB7uILYs8XDg6pNFej5mQA,10419
-iqm_benchmarks-2.24.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-iqm_benchmarks-2.24.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.24.dist-info/RECORD,,
+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.24.dist-info → iqm_benchmarks-2.26.dist-info}/WHEEL

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