iqm-benchmarks 2.21__py3-none-any.whl → 2.23__py3-none-any.whl

iqm/benchmarks/benchmark.py

@@ -23,6 +23,7 @@ from typing import Dict, Literal, Optional, OrderedDict, Type
 from matplotlib.figure import Figure
 from pydantic import BaseModel
 
+from iqm.iqm_client.models import DDStrategy
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -99,6 +100,8 @@ class BenchmarkConfigurationBase(BaseModel):
                 - "fixed": physical layout is constrained during transpilation to the selected initial physical qubits.
                 - "batching": physical layout is allowed to use any other physical qubits, and circuits are batched according to final measured qubits.
                 * Default for all benchmarks is "fixed".
+        use_DD (bool): Boolean flag determining if dynamical decoupling is enabled during circuit execution
+            * Default: False
     """
 
     benchmark: Type[BenchmarkBase]
@@ -107,3 +110,5 @@ class BenchmarkConfigurationBase(BaseModel):
     calset_id: Optional[str] = None
     routing_method: Literal["basic", "lookahead", "stochastic", "sabre", "none"] = "sabre"
     physical_layout: Literal["fixed", "batching"] = "fixed"
+    use_dd: Optional[bool] = False
+    dd_strategy: Optional[DDStrategy] = None

iqm/benchmarks/benchmark_definition.py

@@ -30,7 +30,9 @@ import xarray as xr
 
 from iqm.benchmarks.benchmark import BenchmarkConfigurationBase
 from iqm.benchmarks.circuit_containers import BenchmarkCircuit, Circuits
+from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.utils import get_iqm_backend, timeit
+from iqm.iqm_client.models import CircuitCompilationOptions, DDMode
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 from iqm.qiskit_iqm.iqm_provider import IQMBackend, IQMFacadeBackend
 
@@ -245,6 +247,18 @@ class Benchmark(ABC):
         self.options.update(kwargs)
         self.runs: list[BenchmarkRunResult] = []
 
+        # Circuit compilation options
+        if self.configuration.use_dd:
+            if self.name in ["compressive_GST", "mirror_rb", "interleaved_clifford_rb", "clifford_rb"]:
+                qcvv_logger.warning(
+                    f"Beware that activating dynamical decoupling will change fidelities, error models and their interpretation."
+                )
+            self.circuit_compilation_options = CircuitCompilationOptions(
+                dd_mode=DDMode.ENABLED, dd_strategy=self.configuration.dd_strategy
+            )
+        else:
+            self.circuit_compilation_options = CircuitCompilationOptions(dd_mode=DDMode.DISABLED)
+
     @classmethod
     @abstractmethod
     def name(cls):

iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -102,10 +102,9 @@ class CompressiveGST(Benchmark):
 
         # 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
 
     @timeit
-    def generate_meas_circuits(self) -> None:
+    def generate_meas_circuits(self) -> tuple[BenchmarkCircuit, BenchmarkCircuit]:
         """Generate random circuits from the gate set
 
         The random circuits are distributed among different depths ranging from L_MIN
@@ -115,10 +114,17 @@ class CompressiveGST(Benchmark):
         meaningful results
 
         Returns:
+            transpiled_circuits: BenchmarkCircuit
+                The transpiled circuits
+            untranspiled_circuits: BenchmarkCircuit
+                The untranspiled circuits
             circuit_gen_transp_time: float
                 The time it took to generate and transpile the circuits
-
         """
+
+        transpiled_circuits = BenchmarkCircuit(name="transpiled_circuits")
+        untranspiled_circuits = BenchmarkCircuit(name="untranspiled_circuits")
+
         # Calculate number of short and long circuits
         N_short = int(np.ceil(self.configuration.num_circuits / 2))
         N_long = int(np.floor(self.configuration.num_circuits / 2))
@@ -142,25 +148,54 @@ class CompressiveGST(Benchmark):
                 f"Transpilation on star-architectures currently allows move gates to transit barriers, "
                 f"leading to context-dependent gates which GST can not accurately resolve."
             )
-        for qubits in self.qubit_layouts:
-            coupling_map = set_coupling_map(qubits, self.backend, physical_layout="fixed")
 
-            # Perform transpilation to backend
-            qcvv_logger.info(
-                f"Will transpile all {self.configuration.num_circuits} circuits according to fixed physical layout"
-            )
+        # Perform transpilation to backend
+        qcvv_logger.info(
+            f"Will transpile all {self.configuration.num_circuits} circuits according to fixed physical layout"
+        )
+        if self.configuration.parallel_execution:
+            all_qubits = [qubit for layout in self.qubit_layouts for qubit in layout]
+            if len(all_qubits) != len(set(all_qubits)):
+                raise ValueError(
+                    "Qubit layouts can't overlap when parallel_execution is enabled, please choose non-overlapping layouts."
+                )
+            raw_qc_list_parallel = []
+            for circ in raw_qc_list:
+                circ_parallel = QuantumCircuit(self.backend.num_qubits, len(set(all_qubits)))
+                clbits = np.arange(self.num_qubits)
+                for qubit_layout in self.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,
+                raw_qc_list_parallel,
                 self.backend,
-                qubits,
-                coupling_map=coupling_map,
+                qubits=np.arange(self.backend.num_qubits),
+                coupling_map=self.backend.coupling_map,
                 qiskit_optim_level=0,
                 optimize_sqg=False,
                 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=transpiled_qc_list))
-            self.untranspiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=raw_qc_list))
+            for qubits in self.qubit_layouts:
+                # Saving raw and transpiled circuits in a consistent format with other benchmarks
+                transpiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=transpiled_qc_list))
+                untranspiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=raw_qc_list))
+        else:
+            for qubits in self.qubit_layouts:
+                coupling_map = set_coupling_map(qubits, self.backend, physical_layout="fixed")
+                transpiled_qc_list, _ = perform_backend_transpilation(
+                    raw_qc_list,
+                    self.backend,
+                    qubits,
+                    coupling_map=coupling_map,
+                    qiskit_optim_level=0,
+                    optimize_sqg=False,
+                    drop_final_rz=False,
+                )
+                # Saving raw and transpiled circuits in a consistent format with other benchmarks
+                transpiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=transpiled_qc_list))
+                untranspiled_circuits.circuit_groups.append(CircuitGroup(name=str(qubits), circuits=raw_qc_list))
+        return transpiled_circuits, untranspiled_circuits
 
     def add_configuration_to_dataset(self, dataset):  # CHECK
         """
@@ -190,30 +225,45 @@ class CompressiveGST(Benchmark):
         qcvv_logger.info(f"Now generating {self.configuration.num_circuits} random GST circuits...")
 
         self.circuits = Circuits()
-        self.transpiled_circuits = BenchmarkCircuit(name="transpiled_circuits")
-        self.untranspiled_circuits = BenchmarkCircuit(name="untranspiled_circuits")
         # Generate circuits
-        self.generate_meas_circuits()
+        (transpiled_circuits, untranspiled_circuits), _ = self.generate_meas_circuits()
 
         # Submit all
-        all_jobs: Dict = {}
-        for qubit_layout in self.qubit_layouts:
-            transpiled_circuit_dict = {tuple(qubit_layout): self.transpiled_circuits[str(qubit_layout)].circuits}
-            all_jobs[str(qubit_layout)], _ = submit_execute(
+        if self.configuration.parallel_execution:
+            transpiled_circuit_dict = {
+                tuple(range(self.backend.num_qubits)): transpiled_circuits[str(self.qubit_layouts[0])].circuits
+            }
+            all_jobs_parallel, _ = submit_execute(
                 transpiled_circuit_dict,
                 backend,
                 self.configuration.shots,
                 self.calset_id,
                 max_gates_per_batch=self.configuration.max_gates_per_batch,
+                circuit_compilation_options=self.circuit_compilation_options,
             )
-        # Retrieve all
-        qcvv_logger.info(f"Now executing the corresponding circuit batch")
-        for qubit_layout in self.qubit_layouts:
-            counts, _ = retrieve_all_counts(all_jobs[str(qubit_layout)])
-            dataset, _ = add_counts_to_dataset(counts, str(qubit_layout), dataset)
+            # Retrieve
+            qcvv_logger.info(f"Now executing the corresponding circuit batch")
+            counts, _ = retrieve_all_counts(all_jobs_parallel)
+            dataset, _ = add_counts_to_dataset(counts, f"parallel_results", dataset)
+        else:
+            all_jobs: Dict = {}
+            for qubit_layout in self.qubit_layouts:
+                transpiled_circuit_dict = {tuple(qubit_layout): transpiled_circuits[str(qubit_layout)].circuits}
+                all_jobs[str(qubit_layout)], _ = submit_execute(
+                    transpiled_circuit_dict,
+                    backend,
+                    self.configuration.shots,
+                    self.calset_id,
+                    max_gates_per_batch=self.configuration.max_gates_per_batch,
+                )
+            # Retrieve all
+            qcvv_logger.info(f"Now executing the corresponding circuit batch")
+            for qubit_layout in self.qubit_layouts:
+                counts, _ = retrieve_all_counts(all_jobs[str(qubit_layout)])
+                dataset, _ = add_counts_to_dataset(counts, str(qubit_layout), dataset)
 
+        self.circuits.benchmark_circuits = [transpiled_circuits, untranspiled_circuits]
         self.add_configuration_to_dataset(dataset)
-        self.circuits.benchmark_circuits = [self.transpiled_circuits, self.untranspiled_circuits]
         return dataset
 
 
@@ -270,6 +320,7 @@ class GSTConfiguration(BenchmarkConfigurationBase):
             * Default: "auto"
         bootstrap_samples (int): The number of times the optimization algorithm is repeated on fake data to estimate
             the uncertainty via bootstrapping.
+        parallel_execution (bool): Whether to run the circuits for all layouts in parallel on the backend.
     """
 
     benchmark: Type[Benchmark] = CompressiveGST
@@ -288,6 +339,7 @@ class GSTConfiguration(BenchmarkConfigurationBase):
     batch_size: Union[str, int] = "auto"
     bootstrap_samples: int = 0
     testing: bool = False
+    parallel_execution: bool = False
 
 
 def parse_layouts(qubit_layouts: Union[List[int], List[List[int]]]) -> List[List[int]]:

iqm/benchmarks/compressive_gst/gst_analysis.py

@@ -621,16 +621,29 @@ def dataset_counts_to_mgst_format(dataset: xr.Dataset, qubit_layout: List[int])
     num_povm = dataset.attrs["num_povm"]
     y_list = []
     for run_index in range(dataset.attrs["num_circuits"]):
-        # result = dataset[f"{qubit_layout}_counts_{run_index}"].to_dict()
-        result = dataset[f"{qubit_layout}_state_{run_index}"].data.tolist()
-        basis_dict = {entry: int("".join([entry[::-1][i] for i in range(num_qubits)][::-1]), 2) for entry in result}
+        if dataset.attrs["parallel_execution"]:
+            result_da = dataset[f"parallel_results_counts_{run_index}"].copy()
+            bit_pos = dataset.attrs["qubit_layouts"].index(qubit_layout)
+            # Create a new coordinate of bits at the position given by the qubit layout and reverse order
+            new_coords = [
+                coord[::-1][bit_pos * num_qubits : (bit_pos + 1) * num_qubits]
+                for coord in result_da.coords[result_da.dims[0]].values
+            ]
+        else:
+            result_da = dataset[f"{qubit_layout}_counts_{run_index}"].copy()
+            # Reverse order since counts are stored in qiskit order (bottom to top in circuit diagram)
+            new_coords = [coord[::-1] for coord in result_da.coords[result_da.dims[0]].values]
+        result_da.coords["new_coord"] = (result_da.dims[0], new_coords)
+        result_da = result_da.groupby("new_coord").sum()
+
+        coord_strings = list(result_da.coords[result_da.dims[0]].values)
+        # Translating from binary basis labels to integer POVM labels
+        basis_dict = {entry: int(entry, 2) for entry in coord_strings}
         # Sort by index:
         basis_dict = dict(sorted(basis_dict.items(), key=lambda item: item[1]))
 
-        counts_normalized = (
-            dataset[f"{qubit_layout}_counts_{run_index}"] / dataset[f"{qubit_layout}_counts_{run_index}"].sum()
-        )
-        row = [counts_normalized.loc[key].data for key in basis_dict]
+        counts_normalized = result_da / result_da.sum()
+        row = [float(counts_normalized.loc[key].data) for key in basis_dict]
         # row = [result[key] for key in basis_dict]
         if len(row) < num_povm:
             missing_entries = list(np.arange(num_povm))

iqm/benchmarks/entanglement/ghz.py

@@ -16,9 +16,7 @@
 GHZ state benchmark
 """
 
-from io import BytesIO
 from itertools import chain
-import json
 from time import strftime
 from typing import Any, Dict, List, Optional, Sequence, Tuple, Type, cast
 
@@ -27,7 +25,6 @@ import matplotlib.pyplot as plt
 import networkx
 from networkx import Graph, all_pairs_shortest_path, is_connected, minimum_spanning_tree
 import numpy as np
-import pycurl
 from qiskit import QuantumRegister
 from qiskit.quantum_info import random_clifford
 from qiskit.transpiler import CouplingMap
@@ -48,6 +45,7 @@ from iqm.benchmarks.circuit_containers import BenchmarkCircuit, CircuitGroup, Ci
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.readout_mitigation import apply_readout_error_mitigation
 from iqm.benchmarks.utils import (
+    extract_fidelities,
     perform_backend_transpilation,
     reduce_to_active_qubits,
     retrieve_all_counts,
@@ -387,47 +385,6 @@ def generate_ghz_spanning_tree(
     return qc, list(participating_qubits)
 
 
-def extract_fidelities(cal_url: str, qubit_layout: List[int]) -> Tuple[List[List[int]], List[float]]:
-    """Returns couplings and CZ-fidelities from calibration data URL
-
-    Args:
-        cal_url: str
-            The url under which the calibration data for the backend can be found
-        qubit_layout: List[int]
-            The subset of system-qubits used in the protocol, indexed from 0
-    Returns:
-        list_couplings: List[List[int]]
-            A list of pairs, each of which is a qubit coupling for which the calibration
-            data contains a fidelity.
-        list_fids: List[float]
-            A list of CZ fidelities from the calibration url, ordered in the same way as list_couplings
-    """
-
-    byteobj = BytesIO()  # buffer creation
-    curlobj = pycurl.Curl()  # pylint: disable=c-extension-no-member
-    curlobj.setopt(curlobj.URL, f"{cal_url}")  # type: ignore
-    curlobj.setopt(curlobj.WRITEDATA, byteobj)  # type: ignore
-    curlobj.perform()  # perform file transfer
-    curlobj.close()  # end of session
-    body = byteobj.getvalue()
-    res = json.loads(body.decode())
-
-    qubit_mapping = {qubit: idx for idx, qubit in enumerate(qubit_layout)}
-    list_couplings = []
-    list_fids = []
-    for key in res["metrics"]:
-        if "irb.cz" in key:
-            idx_1 = key.index(".QB")
-            idx_2 = key.index("__QB")
-            idx_3 = key.index(".fidelity")
-            qb1 = int(key[idx_1 + 3 : idx_2]) - 1
-            qb2 = int(key[idx_2 + 4 : idx_3]) - 1
-            if all([qb1 in qubit_layout, qb2 in qubit_layout]):
-                list_couplings.append([qubit_mapping[qb1], qubit_mapping[qb2]])
-                list_fids.append(float(res["metrics"][key]["value"]))
-    return list_couplings, list_fids
-
-
 def get_edges(
     coupling_map: CouplingMap,
     qubit_layout: List[int],
@@ -454,16 +411,17 @@ def get_edges(
     edges_patch = []
     for idx, edge in enumerate(coupling_map):
         if edge[0] in qubit_layout and edge[1] in qubit_layout:
-            edges_patch.append([edge[0], edge[1]])
+            if not set(edge) in edges_patch:
+                edges_patch.append(set(edge))
 
-    if fidelities_cal is not None:
+    if fidelities_cal is not None and edges_cal is not None:
         fidelities_cal = list(
             np.minimum(np.array(fidelities_cal), np.ones(len(fidelities_cal)))
         )  # get rid of > 1 fidelities
         fidelities_patch = []
         for edge in edges_patch:
-            for idx, edge_2 in enumerate(cast(List[int], edges_cal)):
-                if edge == edge_2:
+            for idx, edge_2 in enumerate(edges_cal):
+                if edge == set(edge_2):
                     fidelities_patch.append(fidelities_cal[idx])
         weights = -np.log(np.array(fidelities_patch))
     else:
@@ -666,7 +624,7 @@ class GHZBenchmark(Benchmark):
             else:
                 effective_coupling_map = self.backend.coupling_map
             if self.cal_url:
-                edges_cal, fidelities_cal = extract_fidelities(self.cal_url, qubit_layout)
+                edges_cal, fidelities_cal, _ = extract_fidelities(self.cal_url)
                 graph = get_edges(effective_coupling_map, qubit_layout, edges_cal, fidelities_cal)
             else:
                 graph = get_edges(effective_coupling_map, qubit_layout)
@@ -893,6 +851,7 @@ class GHZBenchmark(Benchmark):
                 self.shots,
                 self.calset_id,
                 max_gates_per_batch=self.max_gates_per_batch,
+                circuit_compilation_options=self.circuit_compilation_options,
             )
 
         # Retrieve all

iqm/benchmarks/optimization/qscore.py

@@ -411,8 +411,7 @@ def qscore_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     backend_name = dataset.attrs["backend_name"]
     timestamp = dataset.attrs["execution_timestamp"]
 
-    max_num_nodes = dataset.attrs["max_num_nodes"]
-    min_num_nodes = dataset.attrs["min_num_nodes"]
+    nodes_list = dataset.attrs["node_numbers"]
     num_instances: int = dataset.attrs["num_instances"]
 
     use_virtual_node: bool = dataset.attrs["use_virtual_node"]
@@ -420,7 +419,6 @@ def qscore_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
     num_qaoa_layers = dataset.attrs["num_qaoa_layers"]
 
     qscore = 0
-    nodes_list = list(range(min_num_nodes, max_num_nodes + 1))
     beta_ratio_list = []
     beta_ratio_std_list = []
     for num_nodes in nodes_list:
@@ -753,17 +751,26 @@ class QScoreBenchmark(Benchmark):
         else:
             nqubits = self.backend.num_qubits
 
-        if self.max_num_nodes is None or self.max_num_nodes == nqubits + 1:
+        if self.custom_qubits_array is not None:
             if self.use_virtual_node:
-                max_num_nodes = nqubits + 1
+                node_numbers = [len(qubit_layout) + 1 for qubit_layout in self.custom_qubits_array]
             else:
-                max_num_nodes = nqubits
+                node_numbers = [len(qubit_layout) for qubit_layout in self.custom_qubits_array]
+
         else:
-            max_num_nodes = self.max_num_nodes
+            if self.max_num_nodes is None or self.max_num_nodes == nqubits + 1:
+                if self.use_virtual_node:
+                    max_num_nodes = nqubits + 1
+                else:
+                    max_num_nodes = nqubits
+            else:
+                max_num_nodes = self.max_num_nodes
+            node_numbers = range(self.min_num_nodes, max_num_nodes + 1)
 
-        dataset.attrs.update({"max_num_nodes": max_num_nodes})
+        dataset.attrs.update({"max_num_nodes": node_numbers[-1]})
+        dataset.attrs.update({"node_numbers": node_numbers})
 
-        for num_nodes in range(self.min_num_nodes, max_num_nodes + 1):
+        for num_nodes in node_numbers:
             qc_list = []
             qc_transpiled_list: List[QuantumCircuit] = []
             execution_results = []
@@ -874,6 +881,7 @@ class QScoreBenchmark(Benchmark):
                         self.shots,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        circuit_compilation_options=self.circuit_compilation_options,
                     )
                     qc_transpiled_list.append(transpiled_qc)
                     qcvv_logger.setLevel(logging.INFO)

iqm/benchmarks/quantum_volume/clops.py

@@ -565,6 +565,7 @@ class CLOPSBenchmark(Benchmark):
             self.num_shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            circuit_compilation_options=self.circuit_compilation_options,
         )
 
         qcvv_logger.info(f"Retrieving counts")

iqm/benchmarks/quantum_volume/quantum_volume.py

@@ -698,12 +698,8 @@ class QuantumVolumeBenchmark(Benchmark):
             self.shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            circuit_compilation_options=self.circuit_compilation_options,
         )
-        # else:
-        # DD IN DIQE VERSION PREVENTS SUBMITTING JOBS DYNAMICALLY:
-        # I.E., IT AUTOMATICALLY RETRIEVES COUNTS
-        # TODO: change this when job manager for DD in Pulla is updated! # pylint: disable=fixme
-        # raise ValueError("Dynamical decoupling is not yet enabled in the new base")
         # qcvv_logger.info(
         #     f"Now executing {self.num_circuits} circuits with default strategy Dynamical Decoupling"
         # )

iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -353,6 +353,7 @@ class CliffordRandomizedBenchmarking(Benchmark):
                         self.backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )
                 qcvv_logger.info(

iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -513,6 +513,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )
                 all_rb_jobs["interleaved"].extend(
@@ -523,6 +524,7 @@ class InterleavedRandomizedBenchmarking(Benchmark):
                         backend,
                         self.calset_id,
                         max_gates_per_batch=self.max_gates_per_batch,
+                        circuit_compilation_options=self.circuit_compilation_options,
                     )
                 )
                 qcvv_logger.info(

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -662,6 +662,7 @@ class MirrorRandomizedBenchmarking(Benchmark):
             self.shots,
             self.calset_id,
             max_gates_per_batch=self.max_gates_per_batch,
+            circuit_compilation_options=self.circuit_compilation_options,
         )
         mrb_submit_results = {
             "qubits": qubits,

iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py

@@ -36,6 +36,7 @@ import xarray as xr
 from iqm.benchmarks.logging_config import qcvv_logger
 from iqm.benchmarks.randomized_benchmarking.multi_lmfit import create_multi_dataset_params, multi_dataset_residual
 from iqm.benchmarks.utils import get_iqm_backend, marginal_distribution, submit_execute, timeit
+from iqm.iqm_client.models import CircuitCompilationOptions
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm import optimize_single_qubit_gates
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
@@ -473,6 +474,7 @@ def submit_sequential_rb_jobs(
     backend_arg: str | IQMBackendBase,
     calset_id: Optional[str] = None,
     max_gates_per_batch: Optional[int] = None,
+    circuit_compilation_options: Optional[CircuitCompilationOptions] = None,
 ) -> List[Dict[str, Any]]:
     """Submit sequential RB jobs for execution in the specified IQMBackend
     Args:
@@ -482,6 +484,7 @@ def submit_sequential_rb_jobs(
         backend_arg (IQMBackendBase): the IQM backend to submit the job
         calset_id (Optional[str]): the calibration identifier
         max_gates_per_batch (Optional[int]): the maximum number of gates per batch
+        circuit_compilation_options (Optional[CircuitCompilationOptions]): Compilation options passed to submit_execute
     Returns:
         Dict with qubit layout, submitted job objects, type (vanilla/DD) and submission time
     """
@@ -496,7 +499,12 @@ def submit_sequential_rb_jobs(
         # Submit - send to execute on backend
         # pylint: disable=unbalanced-tuple-unpacking
         execution_jobs, time_submit = submit_execute(
-            {tuple(qubits): transpiled_circuits[depth]}, backend, shots, calset_id, max_gates_per_batch
+            {tuple(qubits): transpiled_circuits[depth]},
+            backend,
+            shots,
+            calset_id,
+            max_gates_per_batch,
+            circuit_compilation_options=circuit_compilation_options,
         )
         rb_submit_results[depth] = {
             "qubits": qubits,

iqm/benchmarks/utils.py

@@ -17,11 +17,14 @@ General utility functions
 """
 
 from collections import defaultdict
+from dataclasses import dataclass
 from functools import wraps
 from math import floor
+import os
 from time import time
 from typing import Any, Dict, Iterable, List, Literal, Optional, Sequence, Tuple, Union, cast
 
+import matplotlib.pyplot as plt
 from more_itertools import chunked
 from mthree.utils import final_measurement_mapping
 import numpy as np
@@ -29,9 +32,12 @@ from numpy.random import Generator
 from qiskit import ClassicalRegister, transpile
 from qiskit.converters import circuit_to_dag
 from qiskit.transpiler import CouplingMap
+import requests
+from rustworkx import PyGraph, spring_layout, visualization  # pylint: disable=no-name-in-module
 import xarray as xr
 
 from iqm.benchmarks.logging_config import qcvv_logger
+from iqm.iqm_client.models import CircuitCompilationOptions
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm import transpile_to_IQM
 from iqm.qiskit_iqm.fake_backends.fake_adonis import IQMFakeAdonis
@@ -495,8 +501,9 @@ def submit_execute(
     sorted_transpiled_qc_list: Dict[Tuple, List[QuantumCircuit]],
     backend: IQMBackendBase,
     shots: int,
-    calset_id: Optional[str],
-    max_gates_per_batch: Optional[int],
+    calset_id: Optional[str] = None,
+    max_gates_per_batch: Optional[int] = None,
+    circuit_compilation_options: Optional[CircuitCompilationOptions] = None,
 ) -> List[IQMJob]:
     """Submit for execute a list of quantum circuits on the specified Backend.
 
@@ -506,8 +513,11 @@ def submit_execute(
         shots (int): the number of shots per circuit.
         calset_id (Optional[str]): the calibration set ID, uses the latest one if None.
         max_gates_per_batch (int): the maximum number of gates per batch sent to the backend, used to make manageable batches.
+        circuit_compilation_options (CircuitCompilationOptions): Ability to pass a compilation options object,
+            enabling execution with dynamical decoupling, among other options - see qiskit-iqm documentation.
     Returns:
         List[IQMJob]: the IQMJob objects of the executed circuits.
+
     """
     final_jobs = []
     for k in sorted(
@@ -538,7 +548,12 @@ def submit_execute(
                 qcvv_logger.info(
                     f"max_gates_per_batch restriction: submitting subbatch #{index+1} with {len(qc_batch)} circuits corresponding to qubits {list(k)}"
                 )
-                batch_jobs = backend.run(qc_batch, shots=shots, calibration_set_id=calset_id)
+                batch_jobs = backend.run(
+                    qc_batch,
+                    shots=shots,
+                    calibration_set_id=calset_id,
+                    circuit_compilation_options=circuit_compilation_options,
+                )
                 final_batch_jobs.append(batch_jobs)
             final_jobs.extend(final_batch_jobs)
 
@@ -559,3 +574,233 @@ def xrvariable_to_counts(dataset: xr.Dataset, identifier: str, counts_range: int
         dict(zip(list(dataset[f"{identifier}_state_{u}"].data), dataset[f"{identifier}_counts_{u}"].data))
         for u in range(counts_range)
     ]
+
+
+@dataclass
+class GraphPositions:
+    """A class to store and generate graph positions for different chip layouts.
+
+    This class contains predefined node positions for various quantum chip topologies and
+    provides methods to generate positions for different layout types.
+
+    Attributes:
+        garnet_positions (Dict[int, Tuple[int, int]]): Mapping of node indices to (x,y) positions for Garnet chip.
+        deneb_positions (Dict[int, Tuple[int, int]]): Mapping of node indices to (x,y) positions for Deneb chip.
+        predefined_stations (Dict[str, Dict[int, Tuple[int, int]]]): Mapping of chip names to their position dictionaries.
+    """
+
+    garnet_positions = {
+        0: (5.0, 7.0),
+        1: (6.0, 6.0),
+        2: (3.0, 7.0),
+        3: (4.0, 6.0),
+        4: (5.0, 5.0),
+        5: (6.0, 4.0),
+        6: (7.0, 3.0),
+        7: (2.0, 6.0),
+        8: (3.0, 5.0),
+        9: (4.0, 4.0),
+        10: (5.0, 3.0),
+        11: (6.0, 2.0),
+        12: (1.0, 5.0),
+        13: (2.0, 4.0),
+        14: (3.0, 3.0),
+        15: (4.0, 2.0),
+        16: (5.0, 1.0),
+        17: (1.0, 3.0),
+        18: (2.0, 2.0),
+        19: (3.0, 1.0),
+    }
+
+    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),
+        4: (2.0, 3.0),
+        6: (3.0, 3.0),
+    }
+
+    predefined_stations = {
+        "Garnet": garnet_positions,
+        "Deneb": deneb_positions,
+    }
+
+    @staticmethod
+    def create_positions(graph: PyGraph, topology: Optional[str] = None) -> Dict[int, Tuple[float, float]]:
+        """Generate node positions for a given graph and topology.
+
+        Args:
+            graph: The graph to generate positions for.
+            topology: The type of layout to generate. Must be either "star" or "crystal".
+
+        Returns:
+            A dictionary mapping node indices to (x,y) coordinates.
+        """
+        n_nodes = len(graph.node_indices())
+
+        if topology == "star":
+            # Place center node at (0,0)
+            pos = {0: (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):
+                    x = radius * np.cos(angle)
+                    y = radius * np.sin(angle)
+                    pos[i] = (x, y)
+
+        # Crystal and other topologies
+        else:
+            # Fix first node position in bottom right
+            fixed_pos = {0: (1.0, 1.0)}  # For more consistent layouts
+
+            # 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()
+            }
+        return pos
+
+
+def extract_fidelities(cal_url: str) -> tuple[list[list[int]], list[float], str]:
+    """Returns couplings and CZ-fidelities from calibration data URL
+
+    Args:
+        cal_url: str
+            The url under which the calibration data for the backend can be found
+    Returns:
+        list_couplings: List[List[int]]
+            A list of pairs, each of which is a qubit coupling for which the calibration
+            data contains a fidelity.
+        list_fids: List[float]
+            A list of CZ fidelities from the calibration url, ordered in the same way as list_couplings
+        topology: str
+            Name of the chip topology layout, currently either "star" or "crystal"
+    """
+    headers = {"Accept": "application/json", "Authorization": "Bearer " + os.environ["IQM_TOKEN"]}
+    r = requests.get(cal_url, headers=headers, timeout=60)
+    calibration = r.json()
+    cal_keys = {
+        el2["key"]: (i, j) for i, el1 in enumerate(calibration["calibrations"]) for j, el2 in enumerate(el1["metrics"])
+    }
+    list_couplings = []
+    list_fids = []
+    if "double_move_gate_fidelity" in cal_keys.keys():
+        i, j = cal_keys["double_move_gate_fidelity"]
+        topology = "star"
+    else:
+        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])
+        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)}
+    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
+):
+    """Plot a graph showing the quantum chip layout with fidelity information.
+
+    Creates a visualization of the quantum chip topology where nodes represent qubits
+    and edges represent connections between qubits. Edge thickness indicates gate errors
+    (thinner edges mean better fidelity) and selected qubits are highlighted in orange.
+
+    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
+    """
+    edges_cal, fidelities_cal, topology = extract_fidelities(cal_url)
+    weights = -np.log(np.array(fidelities_cal))
+    edges_graph = [tuple(edge) + (weight,) for edge, weight in zip(edges_cal, weights)]
+
+    graph = PyGraph()
+
+    # Add nodes
+    nodes: set[int] = set()
+    for edge in edges_graph:
+        nodes.update(edge[:2])
+    graph.add_nodes_from(list(nodes))
+
+    # Add edges
+    graph.add_edges_from(edges_graph)
+
+    # Define qubit positions in plot
+    if station in GraphPositions.predefined_stations:
+        pos = GraphPositions.predefined_stations[station]
+    else:
+        pos = GraphPositions.create_positions(graph, topology)
+
+    # Define node colors
+    node_colors = ["lightgrey" for _ in range(len(nodes))]
+    if qubit_layouts is not None:
+        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))
+
+    # Draw the graph
+    visualization.mpl_draw(
+        graph,
+        with_labels=True,
+        node_color=node_colors,
+        pos=pos,
+        labels=lambda node: node,
+        width=7 * weights_ordered / np.max(weights_ordered),
+    )  # type: ignore[call-arg]
+
+    # Add edge labels using matplotlib's annotate
+    for edge in edges_graph:
+        x1, y1 = pos[edge[0]]
+        x2, y2 = pos[edge[1]]
+        x = (x1 + x2) / 2
+        y = (y1 + y2) / 2
+        plt.annotate(
+            f"{edge[2]:.1e}",
+            xy=(x, y),
+            xytext=(0, 0),
+            textcoords="offset points",
+            ha="center",
+            va="center",
+            bbox={"boxstyle": "round,pad=0.2", "fc": "white", "ec": "none", "alpha": 0.6},
+        )
+
+    plt.gca().invert_yaxis()
+    plt.title(
+        "Chip layout with selected qubits in orange\n"
+        + "and gate errors indicated by edge thickness (thinner is better)"
+    )
+    plt.show()

{iqm_benchmarks-2.21.dist-info → iqm_benchmarks-2.23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iqm-benchmarks
-Version: 2.21
+Version: 2.23
 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
@@ -24,7 +24,7 @@ Requires-Dist: tabulate<1.0.0,>=0.9.0
 Requires-Dist: uncertainties<3.3.0,>=3.2.2
 Requires-Dist: pycurl<8.0,>=7.45.3
 Requires-Dist: xarray<2025.0.0,>=2024.6.0
-Requires-Dist: types-pycurl
+Requires-Dist: types-requests
 Requires-Dist: myst-nb==1.1.0
 Provides-Extra: cicd
 Requires-Dist: build==1.0.3; extra == "cicd"

{iqm_benchmarks-2.21.dist-info → iqm_benchmarks-2.23.dist-info}/RECORD

@@ -1,43 +1,43 @@
 iqm/benchmarks/__init__.py,sha256=8SRHlADqZjlP8PtbKTMvu-ejpcEZkW8cPmgW8GVKJg8,2638
-iqm/benchmarks/benchmark.py,sha256=SGhBcSxLPUu-cVXAjG4Db2TRobFCRBYoE1NtTDK1lJg,4432
-iqm/benchmarks/benchmark_definition.py,sha256=AZkvANrf0_0glbq_P_uo_YqbBU9IZa2gJlMVz6qT6VU,10500
+iqm/benchmarks/benchmark.py,sha256=F0WdGFpYGVWMeyKmScfM7b7jvuS8P8UArB3_JwUKJrY,4694
+iqm/benchmarks/benchmark_definition.py,sha256=e4xe0wlWKZqj48_6-zTglMaMeoiA9aGkHrrSgoCfPkM,11271
 iqm/benchmarks/circuit_containers.py,sha256=anEtZEsodYqOX-34oZRmuKGeEpp_VfgG5045Mz4-4hI,7562
 iqm/benchmarks/logging_config.py,sha256=U7olP5Kr75AcLJqNODf9VBhJLVqIvA4AYR6J39D5rww,1052
 iqm/benchmarks/readout_mitigation.py,sha256=Q2SOGWTNgmklOYkNxepAaSaXlxSj0QQyymYY1bOkT8A,11756
-iqm/benchmarks/utils.py,sha256=B3dusTNC4n0gW3KZSaQA6ZZeGok3ABtte-N3JEXCtN0,23022
+iqm/benchmarks/utils.py,sha256=ZwAGYIhPe4Ij2Ds8drd_0eHwpdBj1L7rm1d33oqN4L8,31928
 iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=spq6jP0NLbjaJDzESpbfRPs0N_YheFWl2Wa6USHS5sI,22398
-iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=PxCThBfh2zdQpipI-6gAvLKdmkbYv_KSEpejltVkk7o,35330
+iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=D54hnaxxOIyD3ygUMKyxfRMwfUXfK4O5UdzdgscwkHA,25291
+iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=2qY46e-euAcdThcits_Wo7hGb0m69mDZY0d1Qv_wq4M,36104
 iqm/benchmarks/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=tQXKiav6pKZlV3ZU4BOrYrP7PfBAGn0zOsSUORQn5kw,42652
+iqm/benchmarks/entanglement/ghz.py,sha256=HqvdRaiwM879QUrFnULcprdZ-frr1-i4bQ1U8jKjIn0,40993
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=xAv97MRVUNB_YjRbxzM6Ph0Pz0ctJjSA46J9lrbwe-w,37541
+iqm/benchmarks/optimization/qscore.py,sha256=Ns3Sik90YQ_Cry1I5tY-QQWcLukpyipAfVb1Lmkkd7M,37957
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=abuYvc7XaRTuqLDim9jwZvG_W_KybEbiBs6SD0JUtcA,31319
-iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=njX5lBty9jcWMuJnl7uNqRfwE9akMe5gcX-f1_uYDXk,36791
+iqm/benchmarks/quantum_volume/clops.py,sha256=kMzofZEtB_SmbGWcB9LWGbG96I342Im3xIWDt9nTqUY,31393
+iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=2nNlZeR2VhtKkc3gpCkaR24NE23T0aQXNrepTlUL-8I,36549
 iqm/benchmarks/randomized_benchmarking/__init__.py,sha256=IkKo-7zUChxZZd3my_csQCJfJfZNsV3-JTvdG8uqys4,734
 iqm/benchmarks/randomized_benchmarking/clifford_1q.pkl,sha256=vvSd0pRWxtzyirohO9yf_58mjevkc2-pbuWIEb-4gaw,46928
 iqm/benchmarks/randomized_benchmarking/clifford_2q.pkl,sha256=ZipqU3crPhz2T35qGFgB4GvMyoi_7pnu8NqW5ZP8NXg,90707258
 iqm/benchmarks/randomized_benchmarking/multi_lmfit.py,sha256=Se1ygR4mXn_2_P82Ch31KBnCmY-g_A9NKzE9Ir8nEvw,3247
-iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=xMiQyikGEVj3zoFQfVMS50K15MszArc0kiBWvZ7gWL8,41492
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=SKpNukg_vOEVKpd_MAGj4xTFK5FpFJEwx2Zr_2uSUAQ,41867
 iqm/benchmarks/randomized_benchmarking/clifford_rb/__init__.py,sha256=bTDA156LAl7OLGcMec--1nzDrV1XpPRVq3CquTmucgE,677
-iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=v8GDsEC3JscZVJXc6ZqfJaaSb1LocdFTSeOcwHxp50Y,18317
+iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=H-nfuQaIUWcxYeW61iEc79eZwuAFbDvozTVT0xC0HRw,18403
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_hwlpkOj10vyCU4e6eKSX-oLcF2L9na6W2Gt4,681
-iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=4hBjIXxqy18WKC8hgpCU6T6Vv2cvJu4AImj7QQDqI1k,27956
+iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=CsnajadrpxQOqEvX8PpMGB5_9_g6W1IT4aaQRYa1Z08,28128
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=ZekEqI_89nXzGO1vjM-b5Uwwicy59M4fYHXfA-f0MIg,674
-iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=XYJpfXHeN4PtkiuoCQeyRQIeaKr1PxFNasBjLs2ns7k,34830
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=KNIfu3ucb-oxAwOIl5zarRUeWM1SPmiVEQFo6970oUU,34904
 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=ikedzOYC6M0FEaBsbtcWstl2FYQ9eW7i9P4sLw9pRps,26327
+mGST/algorithm.py,sha256=SRwC1sVFShRVxQDfH1bhUvnquvgwJFLSiZ70qo5SwxE,26314
 mGST/compatibility.py,sha256=00DsPnNfOtrQcDTvxBDs-0aMhmuXmOIIxl_Ohy-Emkg,8920
-mGST/low_level_jit.py,sha256=czEk_GV8rlDUD4a5dJOgoTv5_83QuXAEwmSJAMKelRw,26540
+mGST/low_level_jit.py,sha256=uE1D3v01FbPpsbP92C4220OQalzOfxgL1Ku89BNkxLY,27377
 mGST/optimization.py,sha256=YHwkzIkYvsZOPjclR-BCQWh24jeqjuXp0BB0WX5Lwow,10559
-mGST/qiskit_interface.py,sha256=L4H-4SdhP_bjSFFvpQoF1E7EyGbIJ_CI_y4a7_YEwmU,10102
+mGST/qiskit_interface.py,sha256=ajx6Zn5FnrX_T7tMP8xnBLyG4c2ddFRm0Fu2_3r1t30,10118
 mGST/reporting/figure_gen.py,sha256=6Xd8vwfy09hLY1YbJY6TRevuMsQSU4MsWqemly3ZO0I,12970
-mGST/reporting/reporting.py,sha256=We1cccz9BKbITYcSlZHdmBGdjMWAa1xNZe5tKP-yh_E,26004
-iqm_benchmarks-2.21.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-2.21.dist-info/METADATA,sha256=y-gRyH1c_MMl0hDu-Kv6d_yL78We2Ksctl3UkKc_7tE,10384
-iqm_benchmarks-2.21.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-iqm_benchmarks-2.21.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.21.dist-info/RECORD,,
+mGST/reporting/reporting.py,sha256=B8NWfpZrrSmyH7lwZxd0EbZMYLsAGK1YsHRB4D5qXH4,26002
+iqm_benchmarks-2.23.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.23.dist-info/METADATA,sha256=BvgUDcjk3LfQCM3ncFvwEILGrFt9oK471iLIM5P0KL8,10386
+iqm_benchmarks-2.23.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
+iqm_benchmarks-2.23.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.23.dist-info/RECORD,,

{iqm_benchmarks-2.21.dist-info → iqm_benchmarks-2.23.dist-info}/WHEEL

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

mGST/algorithm.py

@@ -83,7 +83,7 @@ def A_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
     # derivative
     Fy = dA_.reshape(n, pdim)
     Y = A.reshape(n, pdim)
-    rGrad = Fy.conj() - Y @ Fy.T @ Y
+    rGrad = 2 * (Fy.conj() - Y @ Fy.T @ Y)
     G = np.array([rGrad, rGrad.conj()]).reshape(-1)
 
     P = np.eye(n) - Y @ Y.T.conj()
@@ -193,7 +193,7 @@ def B_SFN_riem_Hess(K, A, B, y, J, d, r, n_povm, lam=1e-3):
     # derivative
     Fy = dB_.reshape(n)
     Y = B.reshape(n)
-    rGrad = Fy.conj() - Y * (Fy.T @ Y)
+    rGrad = 2 * (Fy.conj() - Y * (Fy.T @ Y))
     G = np.array([rGrad, rGrad.conj()]).reshape(-1)
 
     P = np.eye(n) - np.outer(Y, Y.T.conj())
@@ -297,10 +297,8 @@ def gd(K, E, rho, y, J, d, r, rK, fixed_gates, ls="COBYLA"):
         Fy = dK_[k].reshape(n, pdim)
         Y = K[k].reshape(n, pdim)
         # Riem. gradient taken from conjugate derivative
-        rGrad = Fy.conj() - Y @ Fy.T @ Y
+        rGrad = 2 * (Fy.conj() - Y @ Fy.T @ Y)
         Delta[k] = rGrad
-
-    Delta = tangent_proj(K, Delta, d, rK)
     res = minimize(lineobjf_isom_geodesic, 1e-8, args=(Delta, K, E, rho, J, y), method=ls, options={"maxiter": 200})
     a = res.x
     K_new = update_K_geodesic(K, Delta, a)
@@ -368,7 +366,7 @@ def SFN_riem_Hess(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA", fixed_gates=
         Fy = dK_[k].reshape(n, pdim)
         Y = K[k].reshape(n, pdim)
         # riemannian gradient, taken from conjugate derivative
-        rGrad = Fy.conj() - Y @ Fy.T @ Y
+        rGrad = 2 * (Fy.conj() - Y @ Fy.T @ Y)
         G = np.array([rGrad, rGrad.conj()]).reshape(-1)
 
         P = np.eye(n) - Y @ Y.T.conj()
@@ -471,7 +469,7 @@ def SFN_riem_Hess_full(K, E, rho, y, J, d, r, rK, lam=1e-3, ls="COBYLA"):
     for k in range(d):
         Fy = dK_[k].reshape((n, pdim))
         Y = K[k].reshape((n, pdim))
-        rGrad = Fy.conj() - Y @ Fy.T @ Y
+        rGrad = 2 * (Fy.conj() - Y @ Fy.T @ Y)
 
         G[0, k, :] = rGrad.reshape(-1)
         G[1, k, :] = rGrad.conj().reshape(-1)

mGST/low_level_jit.py

@@ -104,7 +104,7 @@ def contract(X, j_vec):
     return res
 
 
-@njit(cache=True, fastmath=True)
+@njit(cache=True, fastmath=True, parallel=True)
 def objf(X, E, rho, J, y):
     """Calculate the objective function value for matrices, POVM elements, and target values.
 
@@ -132,12 +132,14 @@ def objf(X, E, rho, J, y):
     """
     m = len(J)
     n_povm = y.shape[0]
-    objf_ = 0
+    objf_: float = 0
     for i in prange(m):  # pylint: disable=not-an-iterable
         j = J[i][J[i] >= 0]
-        C = contract(X, j)
+        state = rho
+        for ind in j[::-1]:
+            state = X[ind] @ state
         for o in range(n_povm):
-            objf_ += abs(E[o].conj() @ C @ rho - y[o, i]) ** 2
+            objf_ += abs(E[o].conj() @ state - y[o, i]) ** 2
     return objf_ / m / n_povm
 
 
@@ -240,7 +242,7 @@ def Mp_norm_lower(X_true, E_true, rho_true, X, E, rho, J, n_povm, p):
     return dist ** (1 / p) / m / n_povm, max_dist ** (1 / p)
 
 
-@njit(cache=True)
+@njit(cache=True, parallel=True)
 def dK(X, K, E, rho, J, y, d, r, rK):
     """Compute the derivative of the objective function with respect to the Kraus tensor K.
 
@@ -274,26 +276,32 @@ def dK(X, K, E, rho, J, y, d, r, rK):
         The derivative objective function with respect to the Kraus tensor K,
         reshaped to (d, rK, pdim, pdim), and scaled by 2/m/n_povm.
     """
+    # pylint: disable=too-many-nested-blocks
     K = K.reshape(d, rK, -1)
     pdim = int(np.sqrt(r))
     n_povm = y.shape[0]
     dK_ = np.zeros((d, rK, r))
     dK_ = np.ascontiguousarray(dK_.astype(np.complex128))
     m = len(J)
-    for k in range(d):
+
+    for k in prange(d):  # pylint: disable=not-an-iterable
         for n in range(m):
             j = J[n][J[n] >= 0]
             for i, j_curr in enumerate(j):
                 if j_curr == k:
+                    R = rho.copy()
+                    for ind in j[i + 1 :][::-1]:
+                        R = X[ind] @ R
                     for o in range(n_povm):
-                        L = E[o].conj() @ contract(X, j[:i])
-                        R = contract(X, j[i + 1 :]) @ rho
+                        L = E[o].conj()
+                        for ind in j[:i]:
+                            L = L @ X[ind]
                         D_ind = L @ X[k] @ R - y[o, n]
                         dK_[k] += D_ind * K[k].conj() @ np.kron(L.reshape(pdim, pdim).T, R.reshape(pdim, pdim).T)
     return dK_.reshape(d, rK, pdim, pdim) * 2 / m / n_povm
 
 
-@njit(cache=True)
+@njit(cache=True, parallel=False)
 def dK_dMdM(X, K, E, rho, J, y, d, r, rK):
     """Compute the derivatives of the objective function with respect to K and the
     product of derivatives of the measurement map with respect to K.
@@ -397,7 +405,7 @@ def ddM(X, K, E, rho, J, y, d, r, rK):
     ddK = np.zeros((d**2, rK**2, r, r))
     ddK = np.ascontiguousarray(ddK.astype(np.complex128))
     dconjdK = np.zeros((d**2, rK**2, r, r))
-    dconjdK = np.ascontiguousarray(ddK.astype(np.complex128))
+    dconjdK = np.ascontiguousarray(dconjdK.astype(np.complex128))
     m = len(J)
     for k in range(d**2):
         k1, k2 = local_basis(k, d, 2)
@@ -516,16 +524,17 @@ def dA(X, A, B, J, y, r, pdim, n_povm):
     for k in range(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))
-    dA_ = dA_.astype(np.complex128)
+    dA_ = np.zeros((n_povm, pdim, pdim)).astype(np.complex128)
     m = len(J)
     for n in prange(m):  # pylint: disable=not-an-iterable
-        jE = J[n][J[n] >= 0][0]
-        j = J[n][J[n] >= 0][1:]
+        j = J[n][J[n] >= 0]
         inner_deriv = contract(X, j) @ rho
-        D_ind = E[jE].conj().dot(inner_deriv) - y[n]
-        dA_[jE] += D_ind * A[jE] @ inner_deriv.reshape(pdim, pdim).T.conj()
-    return dA_
+        dA_step = np.zeros((n_povm, pdim, pdim)).astype(np.complex128)
+        for o in range(n_povm):
+            D_ind = E[o].conj() @ inner_deriv - y[o, n]
+            dA_step[o] += D_ind * A[o].conj() @ inner_deriv.reshape(pdim, pdim).T
+        dA_ += dA_step
+    return dA_ * 2 / m / n_povm
 
 
 @njit(parallel=True, cache=True)
@@ -615,13 +624,21 @@ def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
     for n in prange(m):  # pylint: disable=not-an-iterable
         j = J[n][J[n] >= 0]
         R = contract(X, j) @ rho
+        dA_step = np.zeros((n_povm, pdim, pdim)).astype(np.complex128)
+        dMdM_step = np.zeros((n_povm, r, r)).astype(np.complex128)
+        dMconjdM_step = np.zeros((n_povm, r, r)).astype(np.complex128)
+        dconjdA_step = np.zeros((n_povm, r, r)).astype(np.complex128)
         for o in range(n_povm):
             D_ind = E[o].conj() @ R - y[o, n]
             dM = A[o].conj() @ R.reshape(pdim, pdim).T
-            dMdM[o] += np.outer(dM, dM)
-            dMconjdM[o] += np.outer(dM.conj(), dM)
-            dA_[o] += D_ind * dM
-            dconjdA[o] += D_ind * np.kron(np.eye(pdim).astype(np.complex128), R.reshape(pdim, pdim).T)
+            dMdM_step[o] += np.outer(dM, dM)
+            dMconjdM_step[o] += np.outer(dM.conj(), dM)
+            dA_step[o] += D_ind * dM
+            dconjdA_step[o] += D_ind * np.kron(np.eye(pdim).astype(np.complex128), R.reshape(pdim, pdim).T)
+        dA_ += dA_step
+        dMdM += dMdM_step
+        dMconjdM += dMconjdM_step
+        dconjdA += dconjdA_step
     return dA_ * 2 / m / n_povm, dMdM * 2 / m / n_povm, dMconjdM * 2 / m / n_povm, dconjdA * 2 / m / n_povm
 
 

mGST/qiskit_interface.py

@@ -31,7 +31,7 @@ def qiskit_gate_to_operator(gate_set):
     numpy.ndarray
         An array of process matrices. Each element in the array is a 2D NumPy array.
     """
-    return np.array([[Operator(gate).to_matrix()] for gate in gate_set])
+    return np.array([[Operator(gate).reverse_qargs().to_matrix()] for gate in gate_set])
 
 
 def add_idle_gates(gate_set, active_qubits, gate_qubits):

mGST/reporting/reporting.py

@@ -339,7 +339,7 @@ def compute_sparsest_Pauli_Hamiltonian(U_set):
     pdim = U_set.shape[1]
     pp_vecs = []
 
-    for num, U in enumerate(U_set):
+    for _, 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)