iqm-benchmarks 2.4__py3-none-any.whl → 2.6__py3-none-any.whl

iqm/benchmarks/__init__.py

@@ -26,6 +26,7 @@ from .benchmark_definition import (
     BenchmarkRunResult,
 )
 from .circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
+from .compressive_gst.compressive_gst import CompressiveGST, GSTConfiguration
 from .entanglement.ghz import GHZBenchmark, GHZConfiguration
 from .quantum_volume.clops import CLOPSBenchmark, CLOPSConfiguration
 from .quantum_volume.quantum_volume import QuantumVolumeBenchmark, QuantumVolumeConfiguration

iqm/benchmarks/compressive_gst/__init__.py

@@ -17,4 +17,4 @@ as well as full parametrizations of an initial state and a POVM.
 Low rank compression of the process matrix is used to reduce measurement and post-processing overhead.
 """
 
-from . import compressive_gst
+from . import compressive_gst, gst_analysis

iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -34,7 +34,7 @@ from qiskit.circuit.library import CZGate, RGate
 import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
-from iqm.benchmarks.benchmark_definition import Benchmark, add_counts_to_dataset
+from iqm.benchmarks.benchmark_definition import Benchmark, BenchmarkObservationIdentifier, add_counts_to_dataset
 from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Circuits
 from iqm.benchmarks.compressive_gst.gst_analysis import mgst_analysis
 from iqm.benchmarks.logging_config import qcvv_logger
@@ -72,7 +72,9 @@ class CompressiveGST(Benchmark):
         self.pdim = 2**self.num_qubits
         self.num_povm = self.pdim
 
-        self.gate_set, self.gate_labels, self.num_gates = parse_gate_set(configuration, self.num_qubits)
+        self.gate_set, self.gate_labels, self.num_gates = parse_gate_set(
+            configuration, self.num_qubits, self.qubit_layouts
+        )
 
         if configuration.opt_method not in ["GD", "SFN", "auto"]:
             raise ValueError("Invalid optimization method, valid options are: GD, SFN, auto")
@@ -96,10 +98,8 @@ class CompressiveGST(Benchmark):
         else:
             self.batch_size = configuration.batch_size
 
-        self.y, self.J = (
-            np.empty((self.num_povm, self.configuration.num_circuits)),
-            np.empty((self.configuration.num_circuits, self.num_povm)),
-        )  # format used by mGST
+        # Circuit format used by mGST
+        self.J = np.empty((self.configuration.num_circuits, self.num_povm))
         self.bootstrap_results = List[Tuple[np.ndarray]]  # List of GST outcomes from bootstrapping
 
     @staticmethod
@@ -157,10 +157,8 @@ class CompressiveGST(Benchmark):
                 drop_final_rz=False,
             )
             # Saving raw and transpiled circuits in a consistent format with other benchmarks
-            self.transpiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=raw_qc_list))
-            self.untranspiled_circuits.circuit_groups.append(
-                CircuitGroup(name=str(qubits), circuits=transpiled_qc_list)
-            )
+            self.transpiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=transpiled_qc_list))
+            self.untranspiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=raw_qc_list))
 
     def add_configuration_to_dataset(self, dataset):  # CHECK
         """
@@ -287,6 +285,7 @@ class GSTConfiguration(BenchmarkConfigurationBase):
     convergence_criteria: Union[str, List[float]] = [4, 1e-4]
     batch_size: Union[str, int] = "auto"
     bootstrap_samples: int = 0
+    testing: bool = False
 
 
 def parse_layouts(qubit_layouts: Union[List[int], List[List[int]]]) -> List[List[int]]:
@@ -297,7 +296,7 @@ def parse_layouts(qubit_layouts: Union[List[int], List[List[int]]]) -> List[List
             The qubit_layouts on the backend where the gates are defined on
 
     Returns:
-        qubit_layouts: List[List[[int]]
+        qubit_layouts: List[List[int]]
             A properly typed qubit_layout if no Error was raised
     """
     if all(isinstance(qubits, int) for qubits in qubit_layouts):
@@ -316,7 +315,7 @@ def parse_layouts(qubit_layouts: Union[List[int], List[List[int]]]) -> List[List
 
 
 def parse_gate_set(
-    configuration: GSTConfiguration, num_qubits
+    configuration: GSTConfiguration, num_qubits: int, qubit_layouts: List[List[int]]
 ) -> Tuple[List[QuantumCircuit], Dict[str, Dict[int, str]], int]:
     """
     Handles different gate set inputs and produces a valid gate set
@@ -326,12 +325,14 @@ def parse_gate_set(
             Configuration class containing variables
         num_qubits: int
             The number of qubits on which the gate set is defined
+        qubit_layouts: List[List[int]]
+            A List of physical qubit layouts, as specified by integer labels, where the benchmark is meant to be run.
 
     Returns:
         gate_set: List[QuantumCircuit]
             A list of gates defined as quantum circuit objects
-        gate_labels: List[Dict[int, str]]
-            A dictionary with gate names for each layout
+        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.
         num_gates: int
             The number of gates in the gate set
 
@@ -347,23 +348,27 @@ def parse_gate_set(
             "1QXYI, 2QXYCZ, 2QXYCZ_extended, 3QXYCZ."
         )
     if configuration.gate_set in ["1QXYI", "2QXYCZ", "2QXYCZ_extended", "3QXYCZ"]:
-        gate_set, gate_labels, num_gates = create_predefined_gate_set(configuration.gate_set, num_qubits)
-        return gate_set, gate_labels, num_gates
+        gate_set, gate_label_dict, num_gates = create_predefined_gate_set(
+            configuration.gate_set, num_qubits, qubit_layouts
+        )
+        return gate_set, gate_label_dict, num_gates
 
     if isinstance(configuration.gate_set, list):
+        gate_label_dict = {}
         gate_set = configuration.gate_set
         num_gates = len(gate_set)
         if configuration.gate_labels is None:
             gate_labels = {i: f"Gate %i" % i for i in range(num_gates)}
         else:
-            if configuration.gate_labels:
-                if len(configuration.gate_labels) != num_gates:
-                    raise ValueError(
-                        f"The number of gate labels (%i) does not match the number of gates (%i)"
-                        % (len(configuration.gate_labels), num_gates)
-                    )
-                gate_labels = dict(enumerate(configuration.gate_labels))
-        return gate_set, gate_labels, num_gates
+            if len(configuration.gate_labels) != num_gates:
+                raise ValueError(
+                    f"The number of gate labels (%i) does not match the number of gates (%i)"
+                    % (len(configuration.gate_labels), num_gates)
+                )
+            gate_labels = dict(enumerate(configuration.gate_labels))
+        for qubit_layout in qubit_layouts:
+            gate_label_dict.update({BenchmarkObservationIdentifier(qubit_layout).string_identifier: gate_labels})
+        return gate_set, gate_label_dict, num_gates
 
     raise ValueError(
         f"Invalid gate set, choose among 1QXYI, 2QXYCZ, 2QXYCZ_extended,"
@@ -371,7 +376,9 @@ def parse_gate_set(
     )
 
 
-def create_predefined_gate_set(gate_set, num_qubits) -> Tuple[List[QuantumCircuit], Dict, int]:
+def create_predefined_gate_set(
+    gate_set: Union[str, List[Any]], num_qubits: int, qubit_layouts: List[List[int]]
+) -> Tuple[List[QuantumCircuit], Dict[str, Dict[int, str]], int]:
     """Create a list of quantum circuits corresponding to a predefined gate set.
 
     The circuits are assigned to the specified qubit_layouts on the backend only during transipilation, so the qubit labels
@@ -383,7 +390,7 @@ def create_predefined_gate_set(gate_set, num_qubits) -> Tuple[List[QuantumCircui
     Returns:
         gates: List[QuantumCircuit]
             The gate set as a list of circuits
-        gate_labels_dict: Dict[int, str]
+        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.
         num_gates: int
             The number of gates in the gate set
@@ -428,10 +435,10 @@ def create_predefined_gate_set(gate_set, num_qubits) -> Tuple[List[QuantumCircui
             "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)",
+            "Rx(pi/2)-Ry(pi/2)",
+            "Ry(pi/2)-Rx(pi/2)",
+            "Ry(pi/2)-Ry(pi/2)",
             "CZ",
         ]
     elif gate_set == "3QXYCZ":
@@ -459,6 +466,12 @@ def create_predefined_gate_set(gate_set, num_qubits) -> Tuple[List[QuantumCircui
     gates = add_idle_gates(gates, unmapped_qubits, gate_qubits)
     gates = [remove_idle_wires(qc) for qc in gates]
 
-    gate_label_dict = dict(enumerate(gate_labels))
-
+    gate_label_dict = {}
+    for qubit_layout in qubit_layouts:
+        layout_label_dict = dict(enumerate(gate_labels))
+        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])
+        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

@@ -85,6 +85,7 @@ def bootstrap_errors(
     E: ndarray,
     rho: ndarray,
     target_mdl: Model,
+    identifier: str,
     parametric: bool = False,
 ) -> tuple[Any, Any, Any, Any, Any]:
     """Resamples circuit outcomes a number of times and computes GST estimates for each repetition
@@ -113,6 +114,8 @@ def bootstrap_errors(
         Current initial state estimate
     target_mdl : pygsti model object
         The target gate set
+    identifier : str
+        The string identifier of the current benchmark
     parametric : bool
         If set to True, parametric bootstrapping is used, else non-parametric bootstrapping. Default: False
 
@@ -175,7 +178,7 @@ def bootstrap_errors(
             dataset.attrs["J"],
             y_sampled,
             target_mdl,
-            dataset.attrs["gate_labels"],
+            dataset.attrs["gate_labels"][identifier],
         )
         df_g_list.append(df_g.values)
         df_o_list.append(df_o.values)
@@ -291,7 +294,7 @@ def generate_unit_rank_gate_results(
                     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"]))
+                    for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
                 r"Diamond distance": [
                     reporting.number_to_str(
@@ -330,7 +333,7 @@ def generate_unit_rank_gate_results(
         )
 
         df_g_rotation.columns = [f"h_%s" % label for label in pauli_labels]
-        df_g_rotation.rename(index=dataset.attrs["gate_labels"], inplace=True)
+        df_g_rotation.rename(index=dataset.attrs["gate_labels"][identifier], inplace=True)
 
     else:
         df_g_final = DataFrame(
@@ -358,10 +361,11 @@ def generate_unit_rank_gate_results(
             ).T
         )
         df_g_rotation.columns = [f"h_%s" % label for label in pauli_labels]
-        df_g_final.rename(index=dataset.attrs["gate_labels"], inplace=True)
+        df_g_rotation.rename(index=dataset.attrs["gate_labels"][identifier], inplace=True)
+        df_g_final.rename(index=dataset.attrs["gate_labels"][identifier], inplace=True)
 
-    fig_g = dataframe_to_figure(df_g_final, dataset.attrs["gate_labels"])
-    fig_rotation = dataframe_to_figure(df_g_rotation, dataset.attrs["gate_labels"])
+    fig_g = dataframe_to_figure(df_g_final, dataset.attrs["gate_labels"][identifier])
+    fig_rotation = dataframe_to_figure(df_g_rotation, dataset.attrs["gate_labels"][identifier])
     return df_g_final, df_g_rotation, fig_g, fig_rotation
 
 
@@ -403,7 +407,7 @@ def generate_gate_results(
     identifier = BenchmarkObservationIdentifier(qubit_layout).string_identifier
     n_evals = np.min([max_evals, dataset.attrs["pdim"] ** 2])
     X_opt_pp, _, _ = compatibility.std2pp(X_opt, E_opt, rho_opt)
-    df_g_evals = reporting.generate_Choi_EV_table(X_opt, n_evals, dataset.attrs["gate_labels"])
+    df_g_evals = reporting.generate_Choi_EV_table(X_opt, n_evals, dataset.attrs["gate_labels"][identifier])
 
     if dataset.attrs["bootstrap_samples"] > 0:
         X_array, E_array, rho_array, df_g_array, _ = dataset.attrs["results_layout_" + identifier]["bootstrap_data"]
@@ -419,7 +423,7 @@ def generate_gate_results(
         ]
         bootstrap_evals = np.array(
             [
-                reporting.generate_Choi_EV_table(X_array_std[i], n_evals, dataset.attrs["gate_labels"])
+                reporting.generate_Choi_EV_table(X_array_std[i], n_evals, dataset.attrs["gate_labels"][identifier])
                 for i in range(dataset.attrs["bootstrap_samples"])
             ]
         )
@@ -466,15 +470,15 @@ def generate_gate_results(
             {
                 "Avg. gate fidelity": [
                     reporting.number_to_str(df_g.values[i, 0].copy(), precision=5)
-                    for i in range(len(dataset.attrs["gate_labels"]))
+                    for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
                 "Diamond distance": [
                     reporting.number_to_str(df_g.values[i, 1].copy(), precision=5)
-                    for i in range(len(dataset.attrs["gate_labels"]))
+                    for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
                 "Unitarity": [
                     reporting.number_to_str(reporting.unitarities(X_opt_pp)[i], precision=5)
-                    for i in range(len(dataset.attrs["gate_labels"]))
+                    for i in range(len(dataset.attrs["gate_labels"][identifier]))
                 ],
                 # "Entanglemen fidelity to depol. channel": [reporting.number_to_str(reporting.eff_depol_params(X_opt_pp)[i], precision=5)
                 #                                            for i in range(len(gate_labels))],
@@ -490,10 +494,10 @@ def generate_gate_results(
         ]
 
     df_g_evals_final = DataFrame(eval_strs).T
-    df_g_evals_final.rename(index=dataset.attrs["gate_labels"], inplace=True)
+    df_g_evals_final.rename(index=dataset.attrs["gate_labels"][identifier], inplace=True)
 
-    fig_g = dataframe_to_figure(df_g_final, dataset.attrs["gate_labels"])
-    fig_choi = dataframe_to_figure(df_g_evals_final, dataset.attrs["gate_labels"])
+    fig_g = dataframe_to_figure(df_g_final, dataset.attrs["gate_labels"][identifier])
+    fig_choi = dataframe_to_figure(df_g_evals_final, dataset.attrs["gate_labels"][identifier])
     return df_g_final, df_g_evals_final, fig_g, fig_choi
 
 
@@ -570,7 +574,7 @@ def pandas_results_to_observations(
     """
     observation_list: list[BenchmarkObservation] = []
     err = dataset.attrs["bootstrap_samples"] > 0
-    for idx, gate_label in enumerate(dataset.attrs["gate_labels"].values()):
+    for idx, gate_label in enumerate(dataset.attrs["gate_labels"][identifier.string_identifier].values()):
         observation_list.extend(
             [
                 BenchmarkObservation(
@@ -639,7 +643,7 @@ def dataset_counts_to_mgst_format(dataset: xr.Dataset, qubit_layout: List[int])
     return y
 
 
-def run_mGST(
+def run_mGST_wrapper(
     dataset: xr.Dataset, y: ndarray
 ) -> tuple[ndarray, ndarray, ndarray, ndarray, ndarray, ndarray, ndarray, ndarray]:
     """Wrapper function for mGST algorithm execution which prepares an initialization and sets the alg. parameters
@@ -718,7 +722,7 @@ def run_mGST(
         threshold_multiplier=dataset.attrs["convergence_criteria"][0],
         target_rel_prec=dataset.attrs["convergence_criteria"][1],
         init=init_params,
-        testing=False,
+        testing=dataset.attrs["testing"],
     )
 
     return K, X, E, rho, K_target, X_target, E_target, rho_target
@@ -745,7 +749,7 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
         # Main GST reconstruction
         start_timer = perf_counter()
-        K, X, E, rho, K_target, X_target, E_target, rho_target = run_mGST(dataset, y)
+        K, X, E, rho, K_target, X_target, E_target, rho_target = run_mGST_wrapper(dataset, y)
         main_gst_time = perf_counter() - start_timer
 
         # Gauge optimization
@@ -756,7 +760,7 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
         # Quick report
         df_g, _ = reporting.quick_report(
-            X_opt, E_opt, rho_opt, dataset.attrs["J"], y, target_mdl, dataset.attrs["gate_labels"]
+            X_opt, E_opt, rho_opt, dataset.attrs["J"], y, target_mdl, dataset.attrs["gate_labels"][identifier]
         )
 
         # Gate set in the Pauli basis
@@ -779,11 +783,11 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
         ### Bootstrap
         if dataset.attrs["bootstrap_samples"] > 0:
-            bootstrap_results = bootstrap_errors(dataset, y, K, X, E, rho, target_mdl)
+            bootstrap_results = bootstrap_errors(dataset, y, K, X, E, rho, target_mdl, identifier)
             dataset.attrs["results_layout_" + identifier].update({"bootstrap_data": bootstrap_results})
 
         _, df_o_full = reporting.report(
-            X_opt, E_opt, rho_opt, dataset.attrs["J"], y, target_mdl, dataset.attrs["gate_labels"]
+            X_opt, E_opt, rho_opt, dataset.attrs["J"], y, target_mdl, dataset.attrs["gate_labels"][identifier]
         )
         df_o_final, fig_o = generate_non_gate_results(dataset, qubit_layout, df_o_full)
 
@@ -820,7 +824,7 @@ def mgst_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             X_opt_pp,
             X_target_pp,
             basis_labels=pauli_labels,
-            gate_labels=dataset.attrs["gate_labels"],
+            gate_labels=dataset.attrs["gate_labels"][identifier],
             return_fig=True,
         )
         for i, figure in enumerate(figures):

iqm/benchmarks/entanglement/ghz.py

@@ -296,7 +296,7 @@ def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                             value=fidelity[1],
                         )
                     )
-    plots = {"All layout fidelities": plot_fidelities(observation_list, qubit_layouts)}
+    plots = {"All layout fidelities": plot_fidelities(observation_list, dataset, qubit_layouts)}
     return BenchmarkAnalysisResult(dataset=dataset, observations=observation_list, plots=plots)
 
 
@@ -541,13 +541,17 @@ def get_cx_map(qubit_layout: List[int], graph: networkx.Graph) -> list[list[int]
     return cx_map
 
 
-def plot_fidelities(observations: List[BenchmarkObservation], qubit_layouts: List[List[int]]) -> Figure:
+def plot_fidelities(
+    observations: List[BenchmarkObservation], dataset: xr.Dataset, qubit_layouts: List[List[int]]
+) -> Figure:
     """Plots all the fidelities stored in the observations into a single plot of fidelity vs. number of qubits
 
     Parameters
     ----------
     observations: List[BenchmarkObservation]
         A list of Observations, each assumed to be a fidelity
+    dataset: xr.Dataset
+        The experiment dataset containing results and metadata
     qubit_layouts
         The list of qubit layouts as given by the user. This is used to name the layouts in order for identification
         in the plot.
@@ -556,35 +560,51 @@ def plot_fidelities(observations: List[BenchmarkObservation], qubit_layouts: Lis
     fig :Figure
         The figure object with the fidelity plot.
     """
+    timestamp = dataset.attrs["execution_timestamp"]
+    backend_name = dataset.attrs["backend_name"]
+
     fig, ax = plt.subplots()
     layout_short = {str(qubit_layout): f" L{i}" for i, qubit_layout in enumerate(qubit_layouts)}
     recorded_labels = []
+    x_positions = []
+    cmap = plt.cm.get_cmap("winter")
+    # colors = [cmap(0), cmap(1)]
     for i, obs in enumerate(observations):
         label = "With REM" if "rem" in obs.name else "Unmitigated"
         if label in recorded_labels:
             label = "_nolegend_"
         else:
             recorded_labels.append(label)
-        x = sum(c.isdigit() for c in obs.identifier.string_identifier)
+        identifier = obs.identifier.string_identifier
+        x = len(
+            identifier.strip("[]").replace('"', "").replace(" ", "").split(",")
+        )  # pylint: disable=inconsistent-quotes
         y = obs.value
         ax.errorbar(
             x,
             y,
             yerr=obs.uncertainty,
             capsize=4,
-            color="orange" if "rem" in obs.name else "cornflowerblue",
+            color=cmap(0.85) if "rem" in obs.name else cmap(0.15),
             label=label,
             fmt="o",
             alpha=1,
+            mec="black",
             markersize=5,
         )
-        ax.annotate(layout_short[obs.identifier.string_identifier], (x, y))
-    ax.axhline(0.5, linestyle="--", color="black", label="GME threshold")
-    # ax.set_ylim([0,1])
-    ax.set_title("GHZ fidelities of all qubit layouts")
+        x_positions.append(x)
+        ax.annotate(layout_short[identifier], (x, y))
+
+    ax.set_xticks(x_positions, labels=[str(x) for x in x_positions])
+    ax.grid()
+
+    ax.axhline(0.5, linestyle="--", color="red", label="GME threshold")
+    ax.set_ylim((0, 1))
+    ax.set_title(f"GHZ fidelities of all qubit layouts\nbackend: {backend_name} --- {timestamp}")
     ax.set_xlabel("Number of qubits")
     ax.set_ylabel("Fidelity")
-    ax.legend(framealpha=0.5)
+    ax.legend(framealpha=0.5, fontsize=8)
+    plt.gcf().set_dpi(250)
     plt.close()
     return fig
 
@@ -625,6 +645,7 @@ class GHZBenchmark(Benchmark):
         self.mit_shots = configuration.mit_shots
         self.cal_url = configuration.cal_url
         self.timestamp = strftime("%Y%m%d-%H%M%S")
+        self.execution_timestamp = ""
 
     def generate_native_ghz(self, qubit_layout: List[int], qubit_count: int, routine: str) -> CircuitGroup:
         """
@@ -793,12 +814,14 @@ class GHZBenchmark(Benchmark):
             else:
                 dataset.attrs[key] = value
         dataset.attrs[f"backend_name"] = self.backend.name
+        dataset.attrs[f"execution_timestamp"] = self.execution_timestamp
         dataset.attrs["fidelity_routine"] = self.fidelity_routine
 
     def execute(self, backend) -> xr.Dataset:
         """
         Executes the benchmark.
         """
+        self.execution_timestamp = strftime("%Y%m%d-%H%M%S")
         aux_custom_qubits_array = cast(List[List[int]], self.custom_qubits_array).copy()
         dataset = xr.Dataset()
 

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -10,8 +10,8 @@ import warnings
 
 import numpy as np
 from qiskit import transpile
-from qiskit.quantum_info import random_clifford, random_pauli
-from qiskit_aer import Aer
+from qiskit.quantum_info import Clifford, random_clifford, random_pauli
+from qiskit_aer import Aer, AerSimulator
 from scipy.spatial.distance import hamming
 import xarray as xr
 
@@ -262,9 +262,13 @@ def generate_pauli_dressed_mrb_circuits(
     pauli_dressed_circuits_untranspiled: List[QuantumCircuit] = []
     pauli_dressed_circuits_transpiled: List[QuantumCircuit] = []
 
+    sim_method = "stabilizer"
+    simulator = AerSimulator(method=sim_method)
+
     for _ in range(pauli_samples_per_circ):
         # Initialize the quantum circuit object
         circ = QuantumCircuit(num_qubits)
+        circ_untransp = QuantumCircuit(num_qubits)
         # Sample all the random Paulis
         paulis = [random_pauli(num_qubits) for _ in range(depth + 1)]
 
@@ -282,6 +286,7 @@ def generate_pauli_dressed_mrb_circuits(
             )
             circ.barrier()
             circ.compose(cycle_layers[k], inplace=True)
+            circ_untransp.compose(cycle_layers[k], inplace=True)
             circ.barrier()
 
         # Apply middle Pauli
@@ -307,9 +312,6 @@ def generate_pauli_dressed_mrb_circuits(
         for i in range(num_qubits):
             circ.compose(clifford_layer[i].to_instruction().inverse(), qubits=[i], inplace=True)
 
-        # Add measurements
-        circ.measure_all()
-
         # Transpile to backend - no optimize SQG should be used!
         if isinstance(backend_arg, str):
             retrieved_backend = get_iqm_backend(backend_arg)
@@ -317,6 +319,13 @@ def generate_pauli_dressed_mrb_circuits(
             assert isinstance(backend_arg, IQMBackendBase)
             retrieved_backend = backend_arg
 
+        circ_untransp = circ.copy()
+        # Add measurements to untranspiled - after!
+        circ_untranspiled = transpile(Clifford(circ_untransp).to_circuit(), simulator)
+        circ_untranspiled.measure_all()
+
+        # Add measurements to transpiled - before!
+        circ.measure_all()
         circ_transpiled = transpile(
             circ,
             backend=retrieved_backend,
@@ -325,7 +334,7 @@ def generate_pauli_dressed_mrb_circuits(
             routing_method=routing_method,
         )
 
-        pauli_dressed_circuits_untranspiled.append(circ)
+        pauli_dressed_circuits_untranspiled.append(circ_untranspiled)
         pauli_dressed_circuits_transpiled.append(circ_transpiled)
 
     # Store the circuit
@@ -418,14 +427,14 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     observations = {}
     dataset = run.dataset.copy(deep=True)
 
-    shots = dataset.attrs["shots"]
+    # shots = dataset.attrs["shots"]
     num_circuit_samples = dataset.attrs["num_circuit_samples"]
     num_pauli_samples = dataset.attrs["num_pauli_samples"]
 
     density_2q_gates = dataset.attrs["density_2q_gates"]
     two_qubit_gate_ensemble = dataset.attrs["two_qubit_gate_ensemble"]
 
-    max_gates_per_batch = dataset.attrs["max_gates_per_batch"]
+    # max_gates_per_batch = dataset.attrs["max_gates_per_batch"]
 
     # Analyze the results for each qubit layout of the experiment dataset
     qubits_array = dataset.attrs["qubits_array"]
@@ -445,8 +454,9 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     else:
         assigned_mrb_depths = {str(qubits_array[i]): [2 * m for m in depths_array[i]] for i in range(len(depths_array))}
 
-    transpiled_circuits = run.circuits["transpiled_circuits"]
-    simulator = Aer.get_backend("qasm_simulator")
+    mrb_sim_circuits = run.circuits["untranspiled_circuits"]
+    sim_method = "stabilizer"
+    simulator = AerSimulator(method=sim_method)  # Aer.get_backend("stabilizer")
 
     all_noisy_counts: Dict[str, Dict[int, List[Dict[str, int]]]] = {}
     all_noiseless_counts: Dict[str, Dict[int, List[Dict[str, int]]]] = {}
@@ -465,22 +475,12 @@ def mrb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             all_noisy_counts[str(qubits)][depth] = xrvariable_to_counts(
                 dataset, identifier, num_circuit_samples * num_pauli_samples
             )
-
             qcvv_logger.info(f"Depth {depth}")
-            # Execute the quantum circuits on the simulated, ideal backend
-            # pylint: disable=unbalanced-tuple-unpacking
-            all_noiseless_jobs, _ = submit_execute(
-                {tuple(qubits): transpiled_circuits[f"{str(qubits)}_depth_{str(depth)}"].circuits},
-                simulator,
-                shots,
-                calset_id=None,
-                max_gates_per_batch=max_gates_per_batch,
-            )
 
-            # Retrieve counts
-            all_noiseless_counts[str(qubits)][depth], time_retrieve_noiseless[str(qubits)][depth] = retrieve_all_counts(
-                all_noiseless_jobs
-            )
+            mrb_circs = mrb_sim_circuits[f"{str(qubits)}_depth_{str(depth)}"].circuits
+
+            qcvv_logger.info("Getting simulation counts")
+            all_noiseless_counts[str(qubits)][depth] = simulator.run(mrb_circs).result().get_counts()
 
             # Compute polarizations for the current depth
             polarizations[depth] = compute_polarizations(
@@ -695,7 +695,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
             mrb_untranspiled_circuits_lists: Dict[int, List[QuantumCircuit]] = {}
             time_circuit_generation[str(qubits)] = 0
             for depth in assigned_mrb_depths[str(qubits)]:
-                qcvv_logger.info(f"Depth {depth}")
+                qcvv_logger.info(f"Depth {depth} - Generating all circuits")
                 mrb_circuits[depth], elapsed_time = generate_fixed_depth_mrb_circuits(
                     qubits,
                     self.num_circuit_samples,

{iqm_benchmarks-2.4.dist-info → iqm_benchmarks-2.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: iqm-benchmarks
-Version: 2.4
+Version: 2.6
 Summary: A package for implementation of Quantum Characterization, Verification and Validation (QCVV) techniques on IQM's hardware at gate level abstraction
 Author-email: IQM Finland Oy <developers@meetiqm.com>, Aniket Rath <aniket.rath@meetiqm.com>, Jami Rönkkö <jami@meetiqm.com>, Pedro Figueroa Romero <pedro.romero@meetiqm.com>, Vicente Pina Canelles <vicente.pina@meetiqm.com>, Raphael Brieger <raphael.brieger@meetiqm.com>, Stefan Seegerer <stefan.seegerer@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks
@@ -95,6 +95,19 @@ If you have already installed `iqm-benchmarks` and want to get the latest releas
 pip install iqm-benchmarks --upgrade
 ```
 
+## Optional dependencies
+
+Optional dependencies like compressive gate set tomography and jupyter notebooks can be installed as follows:
+```bash
+pip install "iqm-benchmarks[mgst, examples]"
+```
+Current optional dependencies are:
+* `examples`: Jupyter notebooks
+* `mgst`: Compressive gate set tomography
+* `develop`: Development tools
+* `test`: Code testing and Linting
+* `docs`: Documentation building 
+
 ## Development mode _(latest changes: recommended)_
 
 To install in development mode with all required dependencies, you can instead clone the [repository](https://www.github.com/iqm-finland/iqm-benchmarks) and from the project directory run

{iqm_benchmarks-2.4.dist-info → iqm_benchmarks-2.6.dist-info}/RECORD

@@ -1,15 +1,15 @@
-iqm/benchmarks/__init__.py,sha256=sAS6OKctANSzgVUEUWugQs9mcKwG9KOTBEsbSYGxtPc,2201
+iqm/benchmarks/__init__.py,sha256=sFDsukGeEKJfTO3kaBli0bz8gSewemon35yHAx7bOQY,2279
 iqm/benchmarks/benchmark.py,sha256=SGhBcSxLPUu-cVXAjG4Db2TRobFCRBYoE1NtTDK1lJg,4432
 iqm/benchmarks/benchmark_definition.py,sha256=AZkvANrf0_0glbq_P_uo_YqbBU9IZa2gJlMVz6qT6VU,10500
 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=7FlbSH-RJTtQuRYLChwkQV_vBv0ZfMQTH519cAbyxQ4,12252
 iqm/benchmarks/utils.py,sha256=BNbPeNNiFfE72Y-coVjLK3O7y7-j1Ag-l_qyBQsxXRY,20278
-iqm/benchmarks/compressive_gst/__init__.py,sha256=4F_5YxExn4ysGQaEs-WNfm0yiFBxkKtGAYBZFWnRsSk,915
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=pzkqFQQXEZZJmQgwyLo2_eF3rcK3BwXAj5QfY4poczY,21206
-iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=qaF9zDIadPGe9I0l_SC3EfnODZiykzVRxdl4Pu9zZAY,34813
+iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
+iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=LyhuKCq7UvmkcDhgzRm1QuK95eepJlerxqNXuj7llxc,22146
+iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=wMsomKcD5bUhfzAsi9NGw5YMkkcZ-pOFYsZvuCyGHRM,35282
 iqm/benchmarks/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=qg6mw1RydosKdc2KoPi6M3q0Ek7eMBPIkWOJC2ZDx8M,39446
+iqm/benchmarks/entanglement/ghz.py,sha256=e97DMjH-uAuoO7cqoDS_6k7yDr-DjU9soWL2GyTgp8U,40257
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
 iqm/benchmarks/optimization/qscore.py,sha256=6I13YbFvFq1RcX4mYTw6S4ALb4Ix9t7gjlRzZbaTARM,34038
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
@@ -25,19 +25,19 @@ iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=q8bHcrV
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=PlHn1J8VPaJF5csNH8jxcifz_MdisOEPU54kU-FYoLY,26920
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=ZekEqI_89nXzGO1vjM-b5Uwwicy59M4fYHXfA-f0MIg,674
-iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=kYlcH0uFdFZmZhkPPEliUTftfDTpefjFdlTgDDo_NXM,33819
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=AmPAp80wWc_6ao4OMZBUNGX0_WlSnz9utN4436ZcjJ0,33990
 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=jSB9G9uI30zD-IZBJvrvIbdPMXp0elXPxk8F8QeyC3w,26006
+mGST/algorithm.py,sha256=ikedzOYC6M0FEaBsbtcWstl2FYQ9eW7i9P4sLw9pRps,26327
 mGST/compatibility.py,sha256=00DsPnNfOtrQcDTvxBDs-0aMhmuXmOIIxl_Ohy-Emkg,8920
-mGST/low_level_jit.py,sha256=z6taafZOmgIRsnKZKPFN6aJ2daRsVjzOeOk_GtmcdwI,27023
+mGST/low_level_jit.py,sha256=czEk_GV8rlDUD4a5dJOgoTv5_83QuXAEwmSJAMKelRw,26540
 mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
 mGST/qiskit_interface.py,sha256=L4H-4SdhP_bjSFFvpQoF1E7EyGbIJ_CI_y4a7_YEwmU,10102
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
-mGST/reporting/reporting.py,sha256=-XBy3OCJIMOsA8cApwKjhVKBwnjSAoxm-voHNbRWytM,25803
-iqm_benchmarks-2.4.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-2.4.dist-info/METADATA,sha256=Z-c61lqfGdVvhQmYjB7olZYAJyd9pbA7thPWahqFy4E,9103
-iqm_benchmarks-2.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-iqm_benchmarks-2.4.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.4.dist-info/RECORD,,
+mGST/reporting/reporting.py,sha256=We1cccz9BKbITYcSlZHdmBGdjMWAa1xNZe5tKP-yh_E,26004
+iqm_benchmarks-2.6.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.6.dist-info/METADATA,sha256=sKrWhTqD0WfOnCXSxidvds1IR2e74v0Gxa_E6eUMxsk,9506
+iqm_benchmarks-2.6.dist-info/WHEEL,sha256=A3WOREP4zgxI0fKrHUG8DC8013e3dK3n7a6HDbcEIwE,91
+iqm_benchmarks-2.6.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.6.dist-info/RECORD,,

{iqm_benchmarks-2.4.dist-info → iqm_benchmarks-2.6.dist-info}/WHEEL

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

mGST/algorithm.py

@@ -3,7 +3,6 @@ The main algorithm and functions that perform iteration steps
 """
 
 from decimal import Decimal
-import sys
 import time
 from warnings import warn
 
@@ -11,8 +10,10 @@ import numpy as np
 import numpy.linalg as la
 from scipy.linalg import eig, eigh
 from scipy.optimize import minimize
-from tqdm import tqdm
+from tqdm import trange
+from tqdm.contrib.logging import logging_redirect_tqdm
 
+from iqm.benchmarks.logging_config import qcvv_logger
 from mGST.additional_fns import batch, random_gs, transp
 from mGST.low_level_jit import ddA_derivs, ddB_derivs, ddM, dK, dK_dMdM, objf
 from mGST.optimization import (
@@ -683,7 +684,7 @@ def run_mGST(
         )
 
     success = False
-    print(f"Starting mGST optimization...")
+    qcvv_logger.info(f"Starting mGST optimization...")
 
     if init:
         K, E = (init[0], init[1])
@@ -699,35 +700,38 @@ def run_mGST(
     res_list = [objf(X, E, rho, J, y)]
 
     for i in range(max_inits):
-        for _ in tqdm(range(max_iter), file=sys.stdout):
-            yb, Jb = batch(y, J, bsize)
-            K, X, E, rho, A, B = optimize(yb, Jb, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements)
-            res_list.append(objf(X, E, rho, J, y))
-            if res_list[-1] < delta:
-                print(f"Batch optimization successful, improving estimate over full data....")
-                success = True
-                break
+        with logging_redirect_tqdm(loggers=[qcvv_logger]):
+            for _ in trange(max_iter):
+                yb, Jb = batch(y, J, bsize)
+                K, X, E, rho, A, B = optimize(yb, Jb, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements)
+                res_list.append(objf(X, E, rho, J, y))
+                if res_list[-1] < delta:
+                    qcvv_logger.info(f"Batch optimization successful, improving estimate over full data....")
+                    success = True
+                    break
         if testing:
             plot_objf(res_list, delta, f"Objective function for batch optimization")
         if success:
             break
-        print(f"Run ", i, f"failed, trying new initialization...")
+        qcvv_logger.info(f"Run ", i, f"failed, trying new initialization...")
 
     if not success and max_inits > 0:
-        print(f"Success threshold not reached, attempting optimization over full data set...")
-    for _ in tqdm(range(final_iter), file=sys.stdout):
-        K, X, E, rho, A, B = optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements)
-        res_list.append(objf(X, E, rho, J, y))
-        if np.abs(res_list[-2] - res_list[-1]) < delta * target_rel_prec:
-            break
+        qcvv_logger.info(f"Success threshold not reached, attempting optimization over full data set...")
+    with logging_redirect_tqdm(loggers=[qcvv_logger]):
+        for _ in trange(final_iter):
+            K, X, E, rho, A, B = optimize(y, J, d, r, rK, n_povm, method, K, rho, A, B, fixed_elements)
+            res_list.append(objf(X, E, rho, J, y))
+            if np.abs(res_list[-2] - res_list[-1]) < delta * target_rel_prec:
+                break
     if testing:
         plot_objf(res_list, delta, f"Objective function over batches and full data")
     if success or (res_list[-1] < delta):
-        print(f"\t Convergence criterion satisfied")
+        qcvv_logger.info(f"Convergence criterion satisfied")
     else:
-        print(f"\t Convergence criterion not satisfied,", f"try increasing max_iter or using new initializations.")
-    print(
-        f"\t Final objective {Decimal(res_list[-1]):.2e}",
-        f"in time {(time.time() - t0):.2f}s",
+        qcvv_logger.info(
+            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",
     )
     return K, X, E, rho, res_list

mGST/low_level_jit.py

@@ -242,7 +242,7 @@ def Mp_norm_lower(X_true, E_true, rho_true, X, E, rho, J, n_povm, p):
 
 @njit(cache=True)
 def dK(X, K, E, rho, J, y, d, r, rK):
-    """Compute the derivative of the Kraus operator K with respect to its parameters.
+    """Compute the derivative of the objective function with respect to the Kraus tensor K.
 
     This function calculates the derivative of the Kraus operator K, based on the
     input matrices X, E, and rho, as well as the isometry condition.
@@ -271,7 +271,7 @@ def dK(X, K, E, rho, J, y, d, r, rK):
     Returns
     -------
     numpy.ndarray
-        The derivative of the Kraus operator K with respect to its parameters,
+        The derivative objective function with respect to the Kraus tensor K,
         reshaped to (d, rK, pdim, pdim), and scaled by 2/m/n_povm.
     """
     K = K.reshape(d, rK, -1)
@@ -295,7 +295,8 @@ def dK(X, K, E, rho, J, y, d, r, rK):
 
 @njit(cache=True)
 def dK_dMdM(X, K, E, rho, J, y, d, r, rK):
-    """Compute the derivatives of K, dM10, and dM11 for the given input parameters.
+    """Compute the derivatives of the objective function with respect to K and the
+    product of derivatives of the measurement map with respect to K.
 
     This function calculates the derivatives of K, dM10, and dM11 based on the input matrices X,
     matrix K, POVM elements E, density matrix rho, and target values y.
@@ -355,7 +356,7 @@ def dK_dMdM(X, K, E, rho, J, y, d, r, rK):
 
 @njit(cache=True, parallel=False)
 def ddM(X, K, E, rho, J, y, d, r, rK):
-    """Compute the second derivative of the objective function with respect to matrix elements.
+    """Compute the second derivative of the objective function with respect to the Kraus tensor K.
 
     This function calculates the second derivative of the objective function for a given
     set of input parameters.
@@ -481,7 +482,7 @@ def ddM(X, K, E, rho, J, y, d, r, rK):
 
 @njit(parallel=True, cache=True)
 def dA(X, A, B, J, y, r, pdim, n_povm):
-    """Compute the derivative of A with respect to the objective function.
+    """Compute the derivative of to the objective function with respect to the POVM tensor A
 
     This function calculates the gradient of A for a given set of input parameters.
 
@@ -507,7 +508,7 @@ def dA(X, A, B, J, y, r, pdim, n_povm):
     Returns
     -------
     dA : ndarray
-        Derivative of A with respect to the objective function.
+        Derivative of the objective function with respect to A.
     """
     A = np.ascontiguousarray(A)
     B = np.ascontiguousarray(B)
@@ -529,9 +530,7 @@ def dA(X, A, B, J, y, r, pdim, n_povm):
 
 @njit(parallel=True, cache=True)
 def dB(X, A, B, J, y, pdim):
-    """Compute the derivative of B with respect to the objective function.
-
-    This function calculates the gradient of B for a given set of input parameters.
+    """Compute the derivative of the objective function with respect to the state tensor B.
 
     Parameters
     ----------
@@ -551,7 +550,7 @@ def dB(X, A, B, J, y, pdim):
     Returns
     -------
     dB : ndarray
-        Derivative of B with respect to the objective function.
+        Derivative of the objective function with respect to the state tensor B.
     """
     A = np.ascontiguousarray(A)
     B = np.ascontiguousarray(B)
@@ -571,11 +570,7 @@ def dB(X, A, B, J, y, pdim):
 
 @njit(parallel=True, cache=True)
 def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
-    """Calculate the derivatives of a given POVM element with respect to its parameters.
-
-    This function computes the derivatives of the POVM element based on input matrices
-    A, B, and X, as well as the isometry condition. The derivatives are only dependent
-    on one POVM element, and different POVM elements are connected via the isometry condition.
+    """Calculate all nonzero terms of the second derivatives with respect to the POVM tensor A.
 
     Parameters
     ----------
@@ -600,9 +595,9 @@ def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
     -------
     tuple of numpy.ndarray
         A tuple containing the computed derivatives:
-        - dA: The derivative of the POVM element A with respect to its parameters,
+        - dA: The derivative w.r.t. A
         of shape (n_povm, pdim, pdim).
-        - dMdM: The product of the derivatives dM and dM, of shape (n_povm, r, r).
+        - dMdM: The product of the measurement map derivatives dM and dM, of shape (n_povm, r, r).
         - dMconjdM: The product of the conjugate of dM and dM, of shape (n_povm, r, r).
         - dconjdA: The product of the conjugate of dA, of shape (n_povm, r, r).
     """
@@ -613,7 +608,6 @@ def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
         E[k] = (A[k].T.conj() @ A[k]).reshape(-1)
     rho = (B @ B.T.conj()).reshape(-1)
     dA_ = np.zeros((n_povm, pdim, pdim)).astype(np.complex128)
-    dM = np.zeros((pdim, pdim)).astype(np.complex128)
     dMdM = np.zeros((n_povm, r, r)).astype(np.complex128)
     dMconjdM = np.zeros((n_povm, r, r)).astype(np.complex128)
     dconjdA = np.zeros((n_povm, r, r)).astype(np.complex128)
@@ -633,10 +627,7 @@ def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
 
 @njit(parallel=True, cache=True)
 def ddB_derivs(X, A, B, J, y, r, pdim):
-    """Calculate the derivatives of the isometry matrix B with respect to its parameters.
-
-    This function computes the derivatives of the isometry matrix B based on input matrices A and X,
-    as well as the isometry condition.
+    """Calculate all nonzero terms of the second derivative with respect to the state tensor B.
 
     Parameters
     ----------
@@ -659,11 +650,10 @@ def ddB_derivs(X, A, B, J, y, r, pdim):
     -------
     tuple of numpy.ndarray
         A tuple containing the computed derivatives:
-        - dB: The derivative of the isometry matrix B with respect to its parameters,
-        of shape (pdim, pdim).
+        - dB: The derivative w.r.t. B, of shape (pdim, pdim).
         - dMdM: The product of the derivatives dM and dM, of shape (r, r).
         - dMconjdM: The product of the conjugate of dM and dM, of shape (r, r).
-        - dconjdB: The product of the conjugate of dB, of shape (r, r).
+        - dconjdB: The mixed second derivative of by dB and dB*, of shape (r, r).
     """
     n_povm = A.shape[0]
     A = np.ascontiguousarray(A)

mGST/reporting/reporting.py

@@ -17,7 +17,7 @@ from pygsti.tools import change_basis
 from pygsti.tools.optools import compute_povm_map
 from qiskit.quantum_info import SuperOp
 from qiskit.quantum_info.operators.measures import diamond_norm
-from scipy.linalg import logm
+from scipy.linalg import logm, schur
 from scipy.optimize import linear_sum_assignment, minimize
 
 from mGST import additional_fns, algorithm, compatibility, low_level_jit
@@ -339,17 +339,20 @@ def compute_sparsest_Pauli_Hamiltonian(U_set):
     pdim = U_set.shape[1]
     pp_vecs = []
 
-    for U in U_set:
-        evals, evecs = np.linalg.eig(U)
+    for num, U in enumerate(U_set):
+        # Schur decomposition finds the unitary diagonalization of a unitary matrix, which is not always returned by np.linalg.eig
+        T, evecs = schur(U)
+        evals = np.diag(T)
         Pauli_norms = []
+        log_evals = np.log(evals)
         for i in range(2**pdim):
             bits = low_level_jit.local_basis(i, 2, pdim)
-            evals_new = 1j * np.log(evals) + 2 * np.pi * bits
+            evals_new = 1j * log_evals + 2 * np.pi * bits
             H_new = evecs @ np.diag(evals_new) @ evecs.T.conj()
             pp_vec = change_basis(H_new.reshape(-1), "std", "pp")
             Pauli_norms.append(np.linalg.norm(pp_vec, ord=1))
         opt_bits = low_level_jit.local_basis(np.argsort(Pauli_norms)[0], 2, pdim)
-        evals_opt = 1j * np.log(evals) + 2 * np.pi * opt_bits
+        evals_opt = 1j * log_evals + 2 * np.pi * opt_bits
         H_opt = evecs @ np.diag(evals_opt) @ evecs.T.conj()
         pp_vecs.append(change_basis(H_opt.reshape(-1), "std", "pp"))
     pauli_coeffs = np.array(pp_vecs) / np.sqrt(pdim) / np.pi * 2
@@ -401,7 +404,7 @@ def phase_opt(X, K_t):
     K_t = K_t.reshape(d, pdim, pdim)
     K_opt = np.zeros(K.shape).astype(complex)
     for i in range(d):
-        angle_opt = minimize(phase_err, 1e-9, args=(K[i], K_t[i]), method="COBYLA").x
+        angle_opt = minimize(phase_err, 1, bounds=[[-np.pi, np.pi]], args=(K[i], K_t[i])).x
         K_opt[i] = K[i] * np.exp(1j * angle_opt)
     return K_opt