iqm-benchmarks 2.25__py3-none-any.whl → 2.27__py3-none-any.whl

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/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,14 @@ 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 +295,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 +343,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 +447,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 +473,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 +579,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 +760,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 +827,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 +874,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

@@ -205,7 +205,8 @@ def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     dataset = run.dataset
     routine = dataset.attrs["fidelity_routine"]
     qubit_layouts = dataset.attrs["custom_qubits_array"]
-    backend_name = dataset.attrs["backend_name"]
+    backend_topology = dataset.attrs["backend_topology"]
+    backend_num_qubits = dataset.attrs["backend_num_qubits"]
 
     observation_list: list[BenchmarkObservation] = []
     for qubit_layout in qubit_layouts:
@@ -218,7 +219,7 @@ def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 for qc in all_circuits:
                     qc_copy = qc.copy()
                     qc_copy.remove_final_measurements()
-                    deflated_qc = reduce_to_active_qubits(qc_copy, backend_name)
+                    deflated_qc = reduce_to_active_qubits(qc_copy, backend_topology, backend_num_qubits)
                     ideal_probabilities.append(
                         dict(sorted(ideal_simulator.run(deflated_qc).result().get_counts().items()))
                     )
@@ -374,11 +375,11 @@ def generate_ghz_spanning_tree(
     participating_qubits = set(qubit for pair in cx_map[: n_state - 1] for qubit in pair)
 
     relabeling = {idx_old: idx_new for idx_new, idx_old in enumerate(participating_qubits)}
-    n_state_register = QuantumRegister(n_state)
-    qc = QuantumCircuit(n_state_register, name="ghz")
+    qc = QuantumCircuit(n_state, name="ghz")
     qc.h([relabeling[cx_map[0][0]]])
     for _, pair in zip(np.arange(n_state - 1), cx_map):
         relabeled_pair = [relabeling[pair[0]], relabeling[pair[1]]]
+        # This barrier prevents Hadamards from being put at the beginning of the circuit, which would make it more susceptible to phase errors
         qc.barrier(relabeled_pair)
         qc.cx(*relabeled_pair)
     qc.measure_active()
@@ -620,14 +621,11 @@ class GHZBenchmark(Benchmark):
                 qcvv_logger.warning(
                     f"The current backend is a star architecture for which a suboptimal state generation routine is chosen. Consider setting state_generation_routine={routine}."
                 )
-                effective_coupling_map = [[x, y] for x in qubit_layout for y in qubit_layout if x != y]
-            else:
-                effective_coupling_map = self.backend.coupling_map
             if self.cal_url:
                 edges_cal, fidelities_cal, _ = extract_fidelities(self.cal_url)
-                graph = get_edges(effective_coupling_map, qubit_layout, edges_cal, fidelities_cal)
+                graph = get_edges(self.backend.coupling_map, qubit_layout, edges_cal, fidelities_cal)
             else:
-                graph = get_edges(effective_coupling_map, qubit_layout)
+                graph = get_edges(self.backend.coupling_map, qubit_layout)
             ghz, _ = generate_ghz_spanning_tree(graph, qubit_layout, qubit_count)
             circuit_group.add_circuit(ghz)
             ghz_native_transpiled, _ = perform_backend_transpilation(
@@ -670,7 +668,7 @@ class GHZBenchmark(Benchmark):
             else:
                 index_min_depth = np.argmin([c.depth() for c in ghz_native_transpiled])
                 final_ghz = ghz_native_transpiled[index_min_depth]
-                circuit_group.add_circuit([ghz_log[index_min_depth]])
+                circuit_group.add_circuit(ghz_log[index_min_depth])
         self.circuits["untranspiled_circuits"].circuit_groups.append(circuit_group)
         return CircuitGroup(name=f"{qubit_layout}_native_ghz", circuits=[final_ghz[0]])
 
@@ -821,6 +819,8 @@ class GHZBenchmark(Benchmark):
             else:
                 dataset.attrs[key] = value
         dataset.attrs[f"backend_name"] = self.backend.name
+        dataset.attrs[f"backend_topology"] = "star" if "move" in self.backend.operation_names else "crystal"
+        dataset.attrs[f"backend_num_qubits"] = self.backend.num_qubits
         dataset.attrs[f"execution_timestamp"] = self.execution_timestamp
         dataset.attrs["fidelity_routine"] = self.fidelity_routine
 

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})
@@ -855,7 +856,7 @@ class QScoreBenchmark(Benchmark):
                 else:
                     qcvv_logger.setLevel(logging.WARNING)
                     # Account for all-to-all connected backends like Deneb
-                    if "move" in self.backend.operation_names:
+                    if "move" in backend.architecture.gates:
                         # If the circuit is defined on a subset of qubit_set, choose the first qubtis in the set
                         active_qubit_set = qubit_set[: len(qc.qubits)]
                         # All-to-all coupling map on the active qubits

iqm/benchmarks/quantum_volume/clops.py

@@ -514,7 +514,7 @@ class CLOPSBenchmark(Benchmark):
                 parameters = self.generate_random_parameters()
 
                 # Star can't use optimize_sqg as is, yet -> complains about MOVE gate not being IQM native!
-                if optimize_sqg and "move" not in self.backend.operation_names:
+                if optimize_sqg and "move" not in self.backend.architecture.gates:
                     sorted_dict_parametrized[k].append(
                         optimize_single_qubit_gates(  # Optimize SQG seems worth it AFTER assignment
                             qc.assign_parameters(

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/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/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -332,7 +332,7 @@ def generate_pauli_dressed_mrb_circuits(
 
         # Add measurements to transpiled - before!
         circ.measure_all()
-        if "move" in retrieved_backend.operation_names:
+        if "move" in retrieved_backend.architecture.gates:
             # All-to-all coupling map on the active qubits
             effective_coupling_map = [[x, y] for x in qubits for y in qubits if x != y]
         else:
@@ -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/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/utils.py

@@ -45,7 +45,6 @@ from iqm.qiskit_iqm.fake_backends.fake_apollo import IQMFakeApollo
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from iqm.qiskit_iqm.iqm_job import IQMJob
 from iqm.qiskit_iqm.iqm_provider import IQMProvider
-from iqm.qiskit_iqm.iqm_transpilation import optimize_single_qubit_gates
 
 
 def timeit(f):
@@ -169,6 +168,9 @@ def count_native_gates(
         backend = backend_arg
 
     native_operations = backend.operation_names
+
+    if "move" in backend.architecture.gates:
+        native_operations.append("move")
     # Some backends may not include "barrier" in the operation_names attribute
     if "barrier" not in native_operations:
         native_operations.append("barrier")
@@ -301,21 +303,22 @@ def perform_backend_transpilation(
             initial_layout=qubits if aux_qc is None else None,
             routing_method=routing_method,
         )
-        if optimize_sqg:
-            transpiled = optimize_single_qubit_gates(transpiled, drop_final_rz=drop_final_rz)
-        if "move" in backend.operation_names:
+        if "move" in backend.architecture.gates:
             transpiled = transpile_to_IQM(
                 qc, backend=backend, optimize_single_qubits=optimize_sqg, remove_final_rzs=drop_final_rz
             )
         if aux_qc is not None:
-            if "move" in backend.operation_names:
-                if 0 in qubits:
+            if "move" in backend.architecture.gates:
+                if backend.num_qubits in qubits:
                     raise ValueError(
-                        "Label 0 is reserved for Resonator - Please specify computational qubit labels (1,2,...)"
+                        f"Label {backend.num_qubits} is reserved for Resonator - "
+                        f"Please specify computational qubit labels {np.arange(backend.num_qubits)}"
                     )
-                backend_name = "IQMNdonisBackend"
-                transpiled = reduce_to_active_qubits(transpiled, backend_name)
-                transpiled = aux_qc.compose(transpiled, qubits=[0] + qubits, clbits=list(range(qc.num_clbits)))
+                backend_topology = "star"
+                transpiled = reduce_to_active_qubits(transpiled, backend_topology, backend.num_qubits)
+                transpiled = aux_qc.compose(
+                    transpiled, qubits=qubits + [backend.num_qubits], clbits=list(range(qc.num_clbits))
+                )
             else:
                 transpiled = aux_qc.compose(transpiled, qubits=qubits, clbits=list(range(qc.num_clbits)))
 
@@ -323,25 +326,31 @@ def perform_backend_transpilation(
 
     qcvv_logger.info(
         f"Transpiling for backend {backend.name} with optimization level {qiskit_optim_level}, "
-        f"{routing_method} routing method{' and SQG optimization' if optimize_sqg else ''} all circuits"
+        f"{routing_method} routing method{' including SQG optimization' if qiskit_optim_level>0 else ''} all circuits"
     )
 
     if coupling_map == backend.coupling_map:
         transpiled_qc_list = [transpile_and_optimize(qc) for qc in qc_list]
     else:  # The coupling map will be reduced if the physical layout is to be fixed
-        aux_qc_list = [QuantumCircuit(backend.num_qubits, q.num_clbits) for q in qc_list]
+        if "move" in backend.architecture.gates:
+            aux_qc_list = [QuantumCircuit(backend.num_qubits + 1, q.num_clbits) for q in qc_list]
+        else:
+            aux_qc_list = [QuantumCircuit(backend.num_qubits, q.num_clbits) for q in qc_list]
         transpiled_qc_list = [transpile_and_optimize(qc, aux_qc=aux_qc_list[idx]) for idx, qc in enumerate(qc_list)]
 
     return transpiled_qc_list
 
 
-def reduce_to_active_qubits(circuit: QuantumCircuit, backend_name: Optional[str] = None) -> QuantumCircuit:
+def reduce_to_active_qubits(
+    circuit: QuantumCircuit, backend_topology: Optional[str] = None, backend_num_qubits=None
+) -> QuantumCircuit:
     """
     Reduces a quantum circuit to only its active qubits.
 
     Args:
-        backend_name (Optional[str]): The backend name, if any, in which the circuits are defined.
+        backend_topology (Optional[str]): The backend topology to execute the benchmark on.
         circuit (QuantumCircuit): The original quantum circuit.
+        backend_num_qubits (int): The number of qubits in the backend.
 
     Returns:
         QuantumCircuit: A new quantum circuit containing only active qubits.
@@ -351,9 +360,9 @@ def reduce_to_active_qubits(circuit: QuantumCircuit, backend_name: Optional[str]
     for instruction in circuit.data:
         for qubit in instruction.qubits:
             active_qubits.add(circuit.find_bit(qubit).index)
-    if backend_name is not None and backend_name == "IQMNdonisBackend" and 0 not in active_qubits:
+    if backend_topology == "star" and backend_num_qubits not in active_qubits:
         # For star systems, the resonator must always be there, regardless of whether it MOVE gates on it or not
-        active_qubits.add(0)
+        active_qubits.add(backend_num_qubits)
 
     # Create a mapping from old qubits to new qubits
     active_qubits = set(sorted(active_qubits))
@@ -453,12 +462,12 @@ def set_coupling_map(
         ValueError: if the physical layout is not "fixed" or "batching".
     """
     if physical_layout == "fixed":
-        if "move" in backend.operation_names:
-            if 0 in qubits:
-                raise ValueError(
-                    "Label 0 is reserved for Resonator - Please specify computational qubit labels (1,2,...)"
-                )
-            return backend.coupling_map.reduce(mapping=[0] + list(qubits))
+        # if "move" in backend.architecture.gates:
+        #     if 0 in qubits:
+        #         raise ValueError(
+        #             "Label 0 is reserved for Resonator - Please specify computational qubit labels (1,2,...)"
+        #         )
+        #     return backend.coupling_map.reduce(mapping=[0] + list(qubits))
         return backend.coupling_map.reduce(mapping=qubits)
     if physical_layout == "batching":
         return backend.coupling_map
@@ -561,7 +570,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:
@@ -637,13 +646,13 @@ class GraphPositions:
     }
 
     deneb_positions = {
-        0: (2.0, 2.0),
-        1: (1.0, 1.0),
-        3: (2.0, 1.0),
-        5: (3.0, 1.0),
-        2: (1.0, 3.0),
+        6: (2.0, 2.0),
+        0: (1.0, 1.0),
+        1: (2.0, 1.0),
+        2: (3.0, 1.0),
+        3: (1.0, 3.0),
         4: (2.0, 3.0),
-        6: (3.0, 3.0),
+        5: (3.0, 3.0),
     }
 
     predefined_stations = {
@@ -665,15 +674,15 @@ class GraphPositions:
         n_nodes = len(graph.node_indices())
 
         if topology == "star":
-            # Place center node at (0,0)
-            pos = {0: (0.0, 0.0)}
+            # Place resonator node with index n_nodes-1 at (0,0)
+            pos = {n_nodes - 1: (0.0, 0.0)}
 
             if n_nodes > 1:
                 # Place other nodes in a circle around the center
                 angles = np.linspace(0, 2 * np.pi, n_nodes - 1, endpoint=False)
                 radius = 1.0
 
-                for i, angle in enumerate(angles, start=1):
+                for i, angle in enumerate(angles):
                     x = radius * np.cos(angle)
                     y = radius * np.sin(angle)
                     pos[i] = (x, y)
@@ -686,7 +695,7 @@ class GraphPositions:
             # Get spring layout with one fixed position
             pos = {
                 int(k): (float(v[0]), float(v[1]))
-                for k, v in spring_layout(graph, scale=2, pos=fixed_pos, num_iter=300, fixed={0}).items()
+                for k, v in spring_layout(graph, scale=2, pos=fixed_pos, num_iter=500, k=0.15, fixed={0}).items()
             }
         return pos
 
@@ -721,23 +730,21 @@ def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]
         i, j = cal_keys["cz_gate_fidelity"]
         topology = "crystal"
     for item in calibration["calibrations"][i]["metrics"][j]["metrics"]:
-        qb1 = int(item["locus"][0][2:]) if item["locus"][0] != "COMP_R" else 0
-        qb2 = int(item["locus"][1][2:]) if item["locus"][1] != "COMP_R" else 0
-        if topology == "star":
-            list_couplings.append([qb1, qb2])
-        else:
-            list_couplings.append([qb1 - 1, qb2 - 1])
+        qb1 = int(item["locus"][0][2:]) if "COMP" not in item["locus"][0] else 0
+        qb2 = int(item["locus"][1][2:]) if "COMP" not in item["locus"][1] else 0
+        list_couplings.append([qb1 - 1, qb2 - 1])
         list_fids.append(float(item["value"]))
     calibrated_qubits = set(np.array(list_couplings).reshape(-1))
-    qubit_mapping = {qubit: idx for idx, qubit in enumerate(calibrated_qubits)}
+    qubit_mapping = {}
+    if topology == "star":
+        qubit_mapping.update({-1: len(calibrated_qubits)})  # Place resonator qubit as last qubit
+    qubit_mapping.update({qubit: idx for idx, qubit in enumerate(calibrated_qubits)})
     list_couplings = [[qubit_mapping[edge[0]], qubit_mapping[edge[1]]] for edge in list_couplings]
 
     return list_couplings, list_fids, topology
 
 
-def plot_layout_fidelity_graph(
-    cal_url: str, qubit_layouts: Optional[list[list[int]]] = None, station: Optional[str] = None
-):
+def plot_layout_fidelity_graph(cal_url: str, qubit_layouts: Optional[list[list[int]]] = None):
     """Plot a graph showing the quantum chip layout with fidelity information.
 
     Creates a visualization of the quantum chip topology where nodes represent qubits
@@ -747,8 +754,6 @@ def plot_layout_fidelity_graph(
     Args:
         cal_url: URL to retrieve calibration data from
         qubit_layouts: List of qubit layouts where each layout is a list of qubit indices
-        station: Name of the quantum computing station to use predefined positions for.
-                If None, positions will be generated algorithmically.
 
     Returns:
         matplotlib.figure.Figure: The generated figure object containing the graph visualization
@@ -768,6 +773,10 @@ def plot_layout_fidelity_graph(
     # Add edges
     graph.add_edges_from(edges_graph)
 
+    # Extract station name from URL
+    parts = cal_url.strip("/").split("/")
+    station = parts[-2].capitalize()
+
     # Define qubit positions in plot
     if station in GraphPositions.predefined_stations:
         pos = GraphPositions.predefined_stations[station]
@@ -780,21 +789,7 @@ def plot_layout_fidelity_graph(
         for qb in {qb for layout in qubit_layouts for qb in layout}:
             node_colors[qb] = "orange"
 
-    # Ensuring weights are in correct order for the plot
-    edge_list = graph.edge_list()
-    weights_dict = {}
-    edge_pos = set()
-
-    # Create a mapping between edge positions as defined in rustworkx and their weights
-    for e, w in zip(edge_list, weights):
-        pos_tuple = (tuple(pos[e[0]]), tuple(pos[e[1]]))
-        weights_dict[pos_tuple] = w
-        edge_pos.add(pos_tuple)
-
-    # Get corresponding weights in the same order
-    weights_ordered = np.array([weights_dict[edge] for edge in list(edge_pos)])
-
-    plt.subplots(figsize=(6, 6))
+    plt.subplots(figsize=(1.5 * np.sqrt(len(nodes)), 1.5 * np.sqrt(len(nodes))))
 
     # Draw the graph
     visualization.mpl_draw(
@@ -803,7 +798,7 @@ def plot_layout_fidelity_graph(
         node_color=node_colors,
         pos=pos,
         labels=lambda node: node,
-        width=7 * weights_ordered / np.max(weights_ordered),
+        width=5 * weights / np.max(weights),
     )  # type: ignore[call-arg]
 
     # Add edge labels using matplotlib's annotate

{iqm_benchmarks-2.25.dist-info → iqm_benchmarks-2.27.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.25
+Version: 2.27
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Adrian Auer <adrian.auer@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Alessio Calzona <alessio.calzona@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Amin Hosseinkhani <amin.hosseinkhani@meetiqm.com>, Miikka Koistinen <miikka@meetiqm.com>, Nadia Milazzo <nadia.milazzo@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -16,10 +16,11 @@ Requires-Dist: matplotlib<4,>=3.6.3
 Requires-Dist: more-itertools<11.0.0,>=10.1.0
 Requires-Dist: mthree<2.7,>=2.6
 Requires-Dist: networkx<4.0,>=3.3
-Requires-Dist: rustworkx>=0.15.1
+Requires-Dist: rustworkx>=0.16.0
 Requires-Dist: numpy<2.0,>=1.25.2
-Requires-Dist: qiskit<2.0,>=1.0
-Requires-Dist: qiskit-iqm<16.0,>=15.1
+Requires-Dist: qiskit<2.0,>=1.2.4
+Requires-Dist: qiskit-iqm<18.0,>=17.8
+Requires-Dist: iqm-client>=22.7
 Requires-Dist: scikit-optimize<0.11.0,>=0.10.2
 Requires-Dist: tabulate<1.0.0,>=0.9.0
 Requires-Dist: uncertainties<3.3.0,>=3.2.2
@@ -50,6 +51,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.dist-info → iqm_benchmarks-2.27.dist-info}/RECORD

@@ -4,40 +4,40 @@ iqm/benchmarks/benchmark_definition.py,sha256=e4xe0wlWKZqj48_6-zTglMaMeoiA9aGkHr
 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=3k3YkLfqHByedVlnSRCeKnt65J60msylGR18mz8sYAA,33435
+iqm/benchmarks/utils.py,sha256=4Yd1Qa5v8JKW8wEu8b4a1a30twJUOWlY0K-JlW9h5k4,33328
 iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=G9vw5esrSwTVFuFNzL-Oyb1vYuA-HKmdnmnfgV74L54,25459
-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=jA1MaXIyPBwxbN36mTjn_jKaRO5-NdoG0YV-RaujU3s,36450
 iqm/benchmarks/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=jSPcdFf1Xsq09EJXKCVHzNXjQIdAoDg859279wKGjaQ,41075
+iqm/benchmarks/entanglement/ghz.py,sha256=RGA6ynJFsfaCJv0nKccsiIzPk2G-iHHvIeW8LVu30HY,41249
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=59iGjk7foCHlYRs0j8ZVFvvxnEGhr4u2SSpOW3TLNU4,38047
+iqm/benchmarks/optimization/qscore.py,sha256=KOw8fjXeMwCjYvKukpX7IiAqRQrVTkrnIgKjNCPVWdw,38130
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=xlziaxjhJUNyHjBCMzMLeJ9PcFNBtDO7urKvCTBb4sI,31471
+iqm/benchmarks/quantum_volume/clops.py,sha256=fD_eh10qHv_W-_mCA-PjPDIxNJ5sqD7yDkK1UjRsAAo,31474
 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/clifford_1q.pkl,sha256=yrmSJqhv7Lb1yqiqU9-2baqTljJPNmTUPQR-AH6GGfc,7800
+iqm/benchmarks/randomized_benchmarking/clifford_2q.pkl,sha256=mJQLubWPOb-DbmFi4oKYJqAMW_Yyo3eJjRjLGl9Sqmo,10282247
 iqm/benchmarks/randomized_benchmarking/multi_lmfit.py,sha256=Se1ygR4mXn_2_P82Ch31KBnCmY-g_A9NKzE9Ir8nEvw,3247
-iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=6sOGPoeJFVCrvTVhDjxbJPrD728pXTzbhuApEgQH1rc,42304
+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=ksa-R8CMDwXniVNvPky5pogCDmifOqjHd5KNEqGzujs,18560
+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=lhv8703QJY5j-CUMgAyG9RxVhQKrGljejJaxL5GbILg,28442
+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=X5rcmCePbVZ9tsMmh8xw3pTskdMKuHrqW_-pGkX0klg,34982
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=_xdp8XLPcZyuqy7Xz8-K8H7zjgRo9ZxFiDgCXE72gaE,34997
+iqm_benchmarks-2.27.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
-mGST/algorithm.py,sha256=SRwC1sVFShRVxQDfH1bhUvnquvgwJFLSiZ70qo5SwxE,26314
+mGST/algorithm.py,sha256=QnxLJtxZysggLUtbZE-c2MWaFclZB2XUVJhvrmUvjVs,26315
 mGST/compatibility.py,sha256=00DsPnNfOtrQcDTvxBDs-0aMhmuXmOIIxl_Ohy-Emkg,8920
 mGST/low_level_jit.py,sha256=uE1D3v01FbPpsbP92C4220OQalzOfxgL1Ku89BNkxLY,27377
 mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
 mGST/qiskit_interface.py,sha256=ajx6Zn5FnrX_T7tMP8xnBLyG4c2ddFRm0Fu2_3r1t30,10118
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
 mGST/reporting/reporting.py,sha256=B8NWfpZrrSmyH7lwZxd0EbZMYLsAGK1YsHRB4D5qXH4,26002
-iqm_benchmarks-2.25.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-2.25.dist-info/METADATA,sha256=ietRHvwVJDYDtSCZjRtPSLjPjLvq0-4jU7TFZiC9Aa0,10533
-iqm_benchmarks-2.25.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
-iqm_benchmarks-2.25.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.25.dist-info/RECORD,,
+iqm_benchmarks-2.27.dist-info/METADATA,sha256=Kk7NahsiPhEhEGtiR8CWkDNuUZCtysZTwu1QBRHlK2U,10589
+iqm_benchmarks-2.27.dist-info/WHEEL,sha256=L0N565qmK-3nM2eBoMNFszYJ_MTx03_tQ0CQu1bHLYo,91
+iqm_benchmarks-2.27.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.27.dist-info/RECORD,,

{iqm_benchmarks-2.25.dist-info → iqm_benchmarks-2.27.dist-info}/WHEEL

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

mGST/algorithm.py

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