iqm-benchmarks 2.25__tar.gz → 2.26__tar.gz

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/CHANGELOG.rst

@@ -2,6 +2,10 @@
 Changelog
 =========
 
+Version 2.26
+============
+* Changed benchmark observation names and identifiers to be more consistent with guidelines.
+
 Version 2.25
 ============
 * Added optional configuration parameter (`max_circuits_per_batch`) to specify the maximum amount of circuits per batch.

{iqm_benchmarks-2.25/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.26}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.25
+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
 

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/src/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,
@@ -388,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
 
@@ -447,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
 
@@ -460,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)]
@@ -469,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)]
@@ -487,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":
@@ -512,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,"
@@ -528,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-2.25 → iqm_benchmarks-2.26}/src/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-2.25 → iqm_benchmarks-2.26}/src/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})

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/src/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),

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/src/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),

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/src/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),

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/src/iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py

@@ -637,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"
@@ -653,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] = {
@@ -699,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-2.25 → iqm_benchmarks-2.26}/src/iqm/benchmarks/utils.py

@@ -561,7 +561,7 @@ def submit_execute(
                 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)))
+                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:

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26/src/iqm_benchmarks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.25
+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
 

{iqm_benchmarks-2.25 → iqm_benchmarks-2.26}/tests/test_gst.py

@@ -13,13 +13,14 @@ class TestGST:
     @patch('matplotlib.pyplot.figure')
     def test_1q(self, mock_fig):
         minimal_1Q_config = GSTConfiguration(
-            qubit_layouts=[[5], [1]],
+            qubit_layouts=[[4], [1]],
             gate_set="1QXYI",
             num_circuits=10,
             shots=10,
             rank=4,
             bootstrap_samples=2,
             max_iterations=[1, 1],
+            parallel_execution=True,
         )
         benchmark = CompressiveGST(self.backend, minimal_1Q_config)
         benchmark.run()