iqm-benchmarks 2.10__py3-none-any.whl → 2.12__py3-none-any.whl

iqm/benchmarks/compressive_gst/compressive_gst.py

@@ -137,7 +137,11 @@ class CompressiveGST(Benchmark):
         raw_qc_list = qiskit_interface.get_qiskit_circuits(
             gate_circuits, self.gate_set, self.num_qubits, unmapped_qubits
         )
-
+        if "move" in self.backend.operation_names:
+            qcvv_logger.warning(
+                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")
 

iqm/benchmarks/entanglement/ghz.py

@@ -28,7 +28,7 @@ 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, transpile
+from qiskit import QuantumRegister
 from qiskit.quantum_info import random_clifford
 from qiskit.transpiler import CouplingMap
 from qiskit_aer import Aer
@@ -60,47 +60,6 @@ from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
-@timeit
-def append_rms(
-    circuit: QuantumCircuit,
-    num_rms: int,
-    backend: IQMBackendBase,
-    # optimize_sqg: bool = False,
-) -> List[QuantumCircuit]:
-    """
-    Appends 1Q Clifford gates sampled uniformly at random to all qubits in the given circuit.
-    Args:
-        circuit (QuantumCircuit):
-        num_rms (int):
-        backend (Optional[IQMBackendBase]): whether Cliffords are decomposed for the given backend
-    Returns:
-        List[QuantumCircuit] of the original circuit with 1Q Clifford gates appended to it
-    """
-    rm_circuits: list[QuantumCircuit] = []
-    for _ in range(num_rms):
-        rm_circ = circuit.copy()
-        # It shouldn't matter if measurement bits get scrambled
-        rm_circ.remove_final_measurements()
-
-        active_qubits = set()
-        data = rm_circ.data
-        for instruction in data:
-            for qubit in instruction[1]:
-                active_qubits.add(rm_circ.find_bit(qubit)[0])
-
-        for q in active_qubits:
-            if backend is not None:
-                rand_clifford = random_clifford(1).to_circuit()
-            else:
-                rand_clifford = random_clifford(1).to_instruction()
-            rm_circ.compose(rand_clifford, qubits=[q], inplace=True)
-
-        rm_circ.measure_active()
-        rm_circuits.append(transpile(rm_circ, basis_gates=backend.operation_names))
-
-    return rm_circuits
-
-
 def fidelity_ghz_randomized_measurements(
     dataset: xr.Dataset, qubit_layout, ideal_probabilities: List[Dict[str, int]], num_qubits: int, circuits: Circuits
 ) -> tuple[dict[str, Any], dict[str, Any]]:
@@ -257,7 +216,7 @@ def fidelity_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 ideal_simulator = Aer.get_backend("statevector_simulator")
                 ideal_probabilities = []
                 idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
-                all_circuits = run.circuits["transpiled_circuits"][f"{idx}_native_ghz"].circuits
+                all_circuits = run.circuits["untranspiled_circuits"][f"{idx}_rm_circuits"].circuits
                 for qc in all_circuits:
                     qc_copy = qc.copy()
                     qc_copy.remove_final_measurements()
@@ -474,9 +433,8 @@ def get_edges(
         graph: networkx.Graph
             The final weighted graph for the given calibration or coupling map
     """
-    edges_coupling = list(coupling_map.get_edges())[::2]
     edges_patch = []
-    for idx, edge in enumerate(edges_coupling):
+    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]])
 
@@ -681,11 +639,16 @@ class GHZBenchmark(Benchmark):
             )
             final_ghz = ghz_native_transpiled
         elif routine == "tree":
+            # For star architectures, create an effective coupling map that represents all-to-all connectivity
+            if "move" in self.backend.operation_names:
+                effective_coupling_map = [[x, y] for x in qubit_layout for y in qubit_layout if x != y]
+            else:
+                effective_coupling_map = self.backend.coupling_map
             if self.cal_url:
                 edges_cal, fidelities_cal = extract_fidelities(self.cal_url, qubit_layout)
-                graph = get_edges(self.backend.coupling_map, qubit_layout, edges_cal, fidelities_cal)
+                graph = get_edges(effective_coupling_map, qubit_layout, edges_cal, fidelities_cal)
             else:
-                graph = get_edges(self.backend.coupling_map, qubit_layout)
+                graph = get_edges(effective_coupling_map, qubit_layout)
             ghz, _ = generate_ghz_spanning_tree(graph, qubit_layout, qubit_count)
             circuit_group.add_circuit(ghz)
             ghz_native_transpiled, _ = perform_backend_transpilation(
@@ -764,6 +727,60 @@ class GHZBenchmark(Benchmark):
         self.circuits["untranspiled_circuits"].circuit_groups.append(circuit_group)
         return qc_list_transpiled
 
+    @timeit
+    def append_rms(
+        self,
+        num_rms: int,
+        qubit_layout: List[int],
+    ) -> List[QuantumCircuit]:
+        """
+        Appends 1Q Clifford gates sampled uniformly at random to all qubits in the given circuit.
+        Args:
+            num_rms (int):
+                How many randomized measurement circuits are generated
+            qubit_layout List[int]:
+                The subset of system-qubits used in the protocol, indexed from 0
+        Returns:
+            List[QuantumCircuit] of the original circuit with 1Q Clifford gates appended to it
+        """
+        idx = BenchmarkObservationIdentifier(qubit_layout).string_identifier
+        fixed_coupling_map = set_coupling_map(qubit_layout, self.backend, "fixed")
+        circuit = self.circuits["untranspiled_circuits"][f"{qubit_layout}_native_ghz"].circuits[0]
+        rm_circuits: list[QuantumCircuit] = []
+        for _ in range(num_rms):
+            rm_circ = circuit.copy()
+            # It shouldn't matter if measurement bits get scrambled
+            rm_circ.remove_final_measurements()
+            rm_circ.barrier()
+
+            active_qubits = set()
+            data = rm_circ.data
+            for instruction in data:
+                for qubit in instruction[1]:
+                    active_qubits.add(rm_circ.find_bit(qubit)[0])
+            for q in active_qubits:
+                if self.backend is not None:
+                    rand_clifford = random_clifford(1).to_circuit()
+                else:
+                    rand_clifford = random_clifford(1).to_instruction()
+                rm_circ.compose(rand_clifford, qubits=[q], inplace=True)
+
+            rm_circ.measure_active()
+            rm_circuits.append(rm_circ)
+
+        rm_circuits_transpiled, _ = perform_backend_transpilation(
+            rm_circuits,
+            self.backend,
+            qubit_layout,
+            fixed_coupling_map,
+            qiskit_optim_level=self.qiskit_optim_level,
+            optimize_sqg=self.optimize_sqg,
+        )
+        untranspiled_rm_group = CircuitGroup(circuits=rm_circuits, name=f"{idx}_rm_circuits")
+        self.circuits["untranspiled_circuits"].circuit_groups.append(untranspiled_rm_group)
+
+        return rm_circuits_transpiled
+
     def generate_readout_circuit(self, qubit_layout: List[int], qubit_count: int) -> CircuitGroup:
         """
         A wrapper for the creation of different circuits to estimate the fidelity
@@ -788,9 +805,7 @@ class GHZBenchmark(Benchmark):
 
         match self.fidelity_routine:
             case "randomized_measurements":
-                all_circuits_list, _ = append_rms(
-                    transpiled_ghz_group.circuits[0], cast(int, self.num_RMs), self.backend
-                )
+                all_circuits_list, _ = self.append_rms(cast(int, self.num_RMs), qubit_layout)
                 transpiled_ghz_group.circuits = all_circuits_list
             case "coherences":
                 all_circuits_list = self.generate_coherence_meas_circuits(qubit_layout, qubit_count)
@@ -847,7 +862,6 @@ class GHZBenchmark(Benchmark):
             )
 
         # Retrieve all
-        qcvv_logger.info(f"Retrieving counts and adding counts to dataset...")
         for qubit_layout in aux_custom_qubits_array:
             # for qubit_count in self.qubit_counts[idx]:
             Id = BenchmarkObservationIdentifier(qubit_layout)

iqm/benchmarks/optimization/qscore.py

@@ -833,14 +833,21 @@ class QScoreBenchmark(Benchmark):
                     qc_list.append([])
                     qcvv_logger.debug(f"This graph instance has no edges.")
                 else:
-                    # execute for a given num_node and a given instance
-                    coupling_map = self.backend.coupling_map.reduce(qubit_set)
                     qcvv_logger.setLevel(logging.WARNING)
+                    # Account for all-to-all connected backends like Deneb
+                    if "move" in self.backend.operation_names:
+                        # If the circuit is defined on a subset of qubit_set, choose the first qubtis in the set
+                        active_qubit_set = qubit_set[: len(qc.qubits)]
+                        # All-to-all coupling map on the active qubits
+                        effective_coupling_map = [[x, y] for x in active_qubit_set for y in active_qubit_set if x != y]
+                    else:
+                        active_qubit_set = qubit_set
+                        effective_coupling_map = self.backend.coupling_map.reduce(active_qubit_set)
                     transpiled_qc, _ = perform_backend_transpilation(
                         [qc],
                         backend=self.backend,
-                        qubits=qubit_set,
-                        coupling_map=coupling_map,
+                        qubits=active_qubit_set,
+                        coupling_map=effective_coupling_map,
                         qiskit_optim_level=self.qiskit_optim_level,
                         optimize_sqg=self.optimize_sqg,
                         routing_method=self.routing_method,

iqm/benchmarks/quantum_volume/clops.py

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

iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py

@@ -128,6 +128,12 @@ def clifford_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
         }
 
+        if len(qubits) == 1:
+            fidelity_native = rb_fit_results.params["fidelity_per_native_sqg"]
+            processed_results.update(
+                {"avg_native_gate_fidelity": {"value": fidelity_native.value, "uncertainty": fidelity_native.stderr}}
+            )
+
         dataset.attrs[qubits_idx].update(
             {
                 "decay_rate": {"value": popt["decay_rate"].value, "uncertainty": popt["decay_rate"].stderr},

iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py

@@ -75,6 +75,11 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
     interleaved_gate = dataset.attrs["interleaved_gate"]
     interleaved_gate_parameters = dataset.attrs["interleaved_gate_params"]
+    if interleaved_gate_parameters is None:
+        interleaved_gate_string = f"{interleaved_gate}"
+    else:
+        params_string = str(tuple(f"{x:.2f}" for x in interleaved_gate_parameters))
+        interleaved_gate_string = f"{interleaved_gate}{params_string}"
 
     simultaneous_fit = dataset.attrs["simultaneous_fit"]
 
@@ -138,6 +143,7 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
             [list_of_fidelities_clifford, list_of_fidelities_interleaved],
             "interleaved",
             simultaneous_fit,
+            interleaved_gate_string,
         )
         rb_fit_results = lmfit_minimizer(fit_parameters, fit_data, sequence_lengths, exponential_rb)
 
@@ -170,10 +176,31 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
                 "avg_gate_fidelity": {"value": fidelity.value, "uncertainty": fidelity.stderr},
             }
 
+            if len(qubits) == 1 and rb_type == "clifford":
+                fidelity_native = rb_fit_results.params["fidelity_per_native_sqg"]
+                processed_results[rb_type].update(
+                    {
+                        "avg_gate_fidelity_native": {
+                            "value": fidelity_native.value,
+                            "uncertainty": fidelity_native.stderr,
+                        }
+                    }
+                )
+            elif len(qubits) == 2 and rb_type == "clifford" and interleaved_gate_string == "CZGate":
+                fidelity_native_sqg = rb_fit_results.params["fidelity_per_native_sqg"]
+                processed_results[rb_type].update(
+                    {
+                        "avg_gate_fidelity_native_sqg": {
+                            "value": fidelity_native_sqg.value,
+                            "uncertainty": fidelity_native_sqg.stderr,
+                        }
+                    }
+                )
+
             observations.extend(
                 [
                     BenchmarkObservation(
-                        name=f"{key}_{rb_type}",
+                        name=f"{key}_{rb_type}" if "native" not in key else f"{key}",
                         identifier=BenchmarkObservationIdentifier(qubits),
                         value=values["value"],
                         uncertainty=values["uncertainty"],
@@ -206,12 +233,6 @@ def interleaved_rb_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
         obs_dict.update({qubits_idx: processed_results})
 
         # Generate decay plots
-        if interleaved_gate_parameters is None:
-            interleaved_gate_string = f"{interleaved_gate}"
-        else:
-            params_string = str(tuple(f"{x:.2f}" for x in interleaved_gate_parameters))
-            interleaved_gate_string = f"{interleaved_gate}{params_string}"
-
         fig_name, fig = plot_rb_decay(
             "irb",
             [qubits],

iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py

@@ -29,6 +29,7 @@ from iqm.benchmarks.randomized_benchmarking.randomized_benchmarking_common impor
 )
 from iqm.benchmarks.utils import (
     get_iqm_backend,
+    perform_backend_transpilation,
     retrieve_all_counts,
     retrieve_all_job_metadata,
     submit_execute,
@@ -326,16 +327,22 @@ def generate_pauli_dressed_mrb_circuits(
 
         # Add measurements to transpiled - before!
         circ.measure_all()
-        circ_transpiled = transpile(
-            circ,
+        if "move" in retrieved_backend.operation_names:
+            # All-to-all coupling map on the active qubits
+            effective_coupling_map = [[x, y] for x in qubits for y in qubits if x != y]
+        else:
+            effective_coupling_map = retrieved_backend.coupling_map
+        circ_transpiled, _ = perform_backend_transpilation(
+            [circ],
             backend=retrieved_backend,
-            initial_layout=qubits,
-            optimization_level=qiskit_optim_level,
+            qubits=qubits,
+            coupling_map=effective_coupling_map,
+            qiskit_optim_level=qiskit_optim_level,
             routing_method=routing_method,
         )
 
         pauli_dressed_circuits_untranspiled.append(circ_untranspiled)
-        pauli_dressed_circuits_transpiled.append(circ_transpiled)
+        pauli_dressed_circuits_transpiled.append(circ_transpiled[0])
 
     # Store the circuit
     all_circuits.update(

iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py

@@ -89,6 +89,7 @@ def fit_decay_lmfit(
     data: List[List[float]] | List[List[List[float]]],
     rb_identifier: str,
     simultaneous_fit_vars: Optional[List[str]] = None,
+    interleaved_gate_str: Optional[str] = None,
 ) -> Tuple[np.ndarray, Parameters]:
     """Perform a fitting routine for 0th-order (Ap^m+B) RB using lmfit
 
@@ -98,6 +99,7 @@ def fit_decay_lmfit(
         data (List[List[float]] | List[List[List[float]]]): the data to be fitted
         rb_identifier (str): the RB identifier, either "stdrb", "irb" or "mrb"
         simultaneous_fit_vars (List[str], optional): the list of variables used to fit simultaneously
+        interleaved_gate_str (Optional[str]): the name of the interleaved gate in IRB
     Returns:
         A tuple of fitting data (list of lists of average fidelities or polarizations) and MRB fit parameters
     """
@@ -125,6 +127,12 @@ def fit_decay_lmfit(
             )
             params.add(f"p_rb", expr=f"1-depolarization_probability_{1}")
             params.add(f"fidelity_per_clifford", expr=f"p_rb + (1 - p_rb) / (2**{n_qubits})")
+            if n_qubits == 1:
+                # The construction of the 1Q and 2Q Clifford gate dictionaries in "generate_2qubit_cliffords.ipynb"
+                # is based on the reference below; thus the expected amount of 1.875 native gates per Clifford
+                # Native gate set being {I, X(pi/2), X(pi), X(-pi/2), Y(pi/2), Y(pi), Y(-pi)} with X(a)=r(a,0), Y(a)=r(a,pi/2)
+                # Ref: Barends et al., Nature 508, 500-503 (2014); Eq.(S3) of arXiv:1402.4848 [quant-ph]
+                params.add("fidelity_per_native_sqg", expr=f"1 - (1 - (p_rb + (1 - p_rb) / (2**{n_qubits})))/1.875")
         else:
             params = create_multi_dataset_params(
                 func, fit_data, initial_guesses=None, constraints=constraints, simultaneously_fit_vars=None
@@ -140,10 +148,24 @@ def fit_decay_lmfit(
             constraints=None,
             simultaneously_fit_vars=simultaneous_fit_vars,
         )
-        params.add(f"p_rb", expr=f"1-depolarization_probability_{1}")
-        params.add(f"fidelity_per_clifford", expr=f"p_rb + (1 - p_rb) / (2**{n_qubits})")
-        params.add(f"p_irb", expr=f"1-depolarization_probability_{2}")
-        params.add(f"interleaved_fidelity", expr=f"p_irb / p_rb + (1 - p_irb / p_rb) / (2**{n_qubits})")
+        params.add(f"p_rb", expr=f"1.0 - depolarization_probability_{1}")
+        params.add(f"fidelity_per_clifford", expr=f"p_rb + (1.0 - p_rb) / (2.0**{n_qubits})")
+        params.add(f"p_irb", expr=f"1.0 - depolarization_probability_{2}")
+        params.add(f"interleaved_fidelity", expr=f"p_irb / p_rb + (1.0 - p_irb / p_rb) / (2.0**{n_qubits})")
+        if n_qubits == 1:
+            # The construction of the 1Q and 2Q Clifford gate dictionaries in "generate_2qubit_cliffords.ipynb"
+            # is based on the reference below; thus the expected amount of 1.875 native gates per Clifford
+            # Native gate set being {I, X(pi/2), X(pi), X(-pi/2), Y(pi/2), Y(pi), Y(-pi)} with X(a)=r(a,0), Y(a)=r(a,pi/2)
+            # Ref: Barends et al., Nature 508, 500-503 (2014); Eq.(S3) of arXiv:1402.4848 [quant-ph]
+            # For IRB it may be used as proxy to how well (or bad) the assumption of uniform fidelity in native sqg gates holds.
+            params.add("fidelity_per_native_sqg", expr=f"1.0 - (1.0 - fidelity_per_clifford)/1.875")
+        elif n_qubits == 2 and interleaved_gate_str == "CZGate":
+            # Here similarly, we may use Eq.(S8 - S11) of arXiv:1402.4848 [quant-ph]
+            params.add(f"fidelity_clifford_and_interleaved", expr=f"p_irb + (1.0 - p_irb) / (2.0 ** {n_qubits})")
+            params.add(
+                "fidelity_per_native_sqg",
+                expr=f"(1.0 / 33.0) * (4.0 * fidelity_clifford_and_interleaved - 10.0 * interleaved_fidelity + 39.0)",
+            )
 
     return fit_data, params
 
@@ -578,6 +600,8 @@ def plot_rb_decay(
     stddevs_from_mean = {}
     fidelity_value = {}
     fidelity_stderr = {}
+    fidelity_native1q_value = {}
+    fidelity_native1q_stderr = {}
     decay_rate = {}
     offset = {}
     amplitude = {}
@@ -618,6 +642,14 @@ def plot_rb_decay(
                 str(q): dataset.attrs[q_idx]["avg_fidelities_stderr"]
                 for q_idx, q in enumerate(qubits_array, qubits_index)
             }
+            fidelity_native1q_value[identifier] = {
+                str(q): observations[q_idx]["avg_native_gate_fidelity"]["value"] if len(q) == 1 else np.nan
+                for q_idx, q in enumerate(qubits_array, qubits_index)
+            }
+            fidelity_native1q_stderr[identifier] = {
+                str(q): observations[q_idx]["avg_native_gate_fidelity"]["uncertainty"] if len(q) == 1 else np.nan
+                for q_idx, q in enumerate(qubits_array, qubits_index)
+            }
         # These are common to both MRB and standard Clifford
         fidelity_value[identifier] = {
             str(q): observations[q_idx]["avg_gate_fidelity"]["value"]
@@ -636,7 +668,7 @@ def plot_rb_decay(
         amplitude[identifier] = {
             str(q): dataset.attrs[q_idx]["fit_amplitude"]["value"] for q_idx, q in enumerate(qubits_array, qubits_index)
         }
-    else:  # id MRB
+    else:  # id IRB
         rb_type_keys = list(observations[0].keys())
         colors = [cmap(i) for i in np.linspace(start=1, stop=0, num=len(rb_type_keys)).tolist()]
         for rb_type in rb_type_keys:
@@ -791,12 +823,12 @@ def plot_rb_decay(
             if identifier == "mrb":
                 plot_label = fr"$\overline{{F}}_{{MRB}} (n={len(qubits)})$ = {100.0 * fidelity_value[key][str(qubits)]:.2f} +/- {100.0 * fidelity_stderr[key][str(qubits)]:.2f} (%)"
             elif key == "interleaved":
-                plot_label = fr"$\overline{{F}}_{{{interleaved_gate}}} ({qubits})$ = {100.0 * fidelity_value[key][str(qubits)]:.2f} +/- {100.0 * fidelity_stderr[key][str(qubits)]:.2f} (%)"
-            else:
-                print(fidelity_value)
-                print(qubits)
-                print(key)
-                plot_label = fr"$\overline{{F}}_{{CRB}}$ = {100.0 * fidelity_value[key][str(qubits)]:.2f} +/- {100.0 * fidelity_stderr[key][str(qubits)]:.2f} (%)"
+                plot_label = fr"$\overline{{F}}_{{{interleaved_gate}}}$ = {100.0 * fidelity_value[key][str(qubits)]:.2f} +/- {100.0 * fidelity_stderr[key][str(qubits)]:.2f} (%)"
+            else:  # if id is "clifford"
+                if len(qubits) == 1 and identifier != "irb":
+                    plot_label = fr"$\overline{{F}}_{{native\_sqg}} \simeq$ {100.0 * fidelity_native1q_value[key][str(qubits)]:.2f} +/- {100.0 * fidelity_native1q_stderr[key][str(qubits)]:.2f} (%)"
+                else:
+                    plot_label = fr"$\overline{{F}}_{{CRB}}$ = {100.0 * fidelity_value[key][str(qubits)]:.2f} +/- {100.0 * fidelity_stderr[key][str(qubits)]:.2f} (%)"
 
             ax.plot(
                 x_linspace,

iqm/benchmarks/utils.py

@@ -230,6 +230,9 @@ def perform_backend_transpilation(
 
     Returns:
         List[QuantumCircuit]: A list of transpiled quantum circuits.
+
+    Raises:
+        ValueError: if Star topology and label 0 is in qubit layout.
     """
 
     # Helper function considering whether optimize_sqg is done,
@@ -245,13 +248,18 @@ def perform_backend_transpilation(
         )
         if optimize_sqg:
             transpiled = optimize_single_qubit_gates(transpiled, drop_final_rz=drop_final_rz)
-        if backend.name == "IQMNdonisBackend":
+        if "move" in backend.operation_names:
             transpiled = transpile_to_IQM(
                 transpiled, backend=backend, optimize_single_qubits=optimize_sqg, remove_final_rzs=drop_final_rz
             )
         if aux_qc is not None:
-            if backend.name == "IQMNdonisBackend":
-                transpiled = reduce_to_active_qubits(transpiled, backend.name)
+            if "move" in backend.operation_names:
+                if 0 in qubits:
+                    raise ValueError(
+                        "Label 0 is reserved for Resonator - Please specify computational qubit labels (1,2,...)"
+                    )
+                backend_name = "IQMNdonisBackend"
+                transpiled = reduce_to_active_qubits(transpiled, backend_name)
                 transpiled = aux_qc.compose(transpiled, qubits=[0] + qubits, clbits=list(range(qc.num_clbits)))
             else:
                 transpiled = aux_qc.compose(transpiled, qubits=qubits, clbits=list(range(qc.num_clbits)))
@@ -384,9 +392,17 @@ def set_coupling_map(
                 * Default is "fixed".
     Returns:
         A coupling map according to the specified physical layout.
+
+    Raises:
+        ValueError: if Star topology and label 0 is in qubit layout.
+        ValueError: if the physical layout is not "fixed" or "batching".
     """
     if physical_layout == "fixed":
-        if backend.name == "IQMNdonisBackend":
+        if "move" in backend.operation_names:
+            if 0 in qubits:
+                raise ValueError(
+                    "Label 0 is reserved for Resonator - Please specify computational qubit labels (1,2,...)"
+                )
             return backend.coupling_map.reduce(mapping=[0] + list(qubits))
         return backend.coupling_map.reduce(mapping=qubits)
     if physical_layout == "batching":

{iqm_benchmarks-2.10.dist-info → iqm_benchmarks-2.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: iqm-benchmarks
-Version: 2.10
+Version: 2.12
 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>, Miikka Koistinen <miikka@meetiqm.com>
 Project-URL: Homepage, https://github.com/iqm-finland/iqm-benchmarks

{iqm_benchmarks-2.10.dist-info → iqm_benchmarks-2.12.dist-info}/RECORD

@@ -4,28 +4,28 @@ iqm/benchmarks/benchmark_definition.py,sha256=AZkvANrf0_0glbq_P_uo_YqbBU9IZa2gJl
 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=MrGWVB4X037u0XZY68PtIEG8Xud3T0ZKldv2JpeLYD0,20500
+iqm/benchmarks/utils.py,sha256=q4U3nuIOyLHhft8ixDXtV48KGm0uiV4tdtlWpGM1O1M,21180
 iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peipukShhkrdaTRCA,929
-iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=bG-NdSbiYTqfTGpBZtHqsjepNwUU04VB0wrqg9KH8OA,22104
+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/entanglement/__init__.py,sha256=9T7prOwqMmFWdb4t6ETAHZXKK5o6FvU2DvVb6WhNi-U,682
-iqm/benchmarks/entanglement/ghz.py,sha256=e97DMjH-uAuoO7cqoDS_6k7yDr-DjU9soWL2GyTgp8U,40257
+iqm/benchmarks/entanglement/ghz.py,sha256=oNf4TE7zEh0fgmz6RaJG0luZZNc6h2Dgohf9KLGKryc,41251
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=nkvt6zJTQclknBmUaliKP0f6Vtgvx4BvNtgVwT7W-1k,34606
+iqm/benchmarks/optimization/qscore.py,sha256=8y3MTCGXkVIMqSs9fGRwBENOvISSFBKLBoATc893yVk,35164
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
-iqm/benchmarks/quantum_volume/clops.py,sha256=j6BPEj1rKBAHigox7nrvaTLyb4iCrHadBl2d1yiETDA,30956
+iqm/benchmarks/quantum_volume/clops.py,sha256=aLxq2sC6cvRmtbmgr7TvluE2edkARH_ZzpTD1LEQEjw,30957
 iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=njX5lBty9jcWMuJnl7uNqRfwE9akMe5gcX-f1_uYDXk,36791
 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=7vp2BEXSYz3Q7u_42qPKlQtdWPAI-a90tmtlhThWLjg,38809
+iqm/benchmarks/randomized_benchmarking/randomized_benchmarking_common.py,sha256=xMiQyikGEVj3zoFQfVMS50K15MszArc0kiBWvZ7gWL8,41492
 iqm/benchmarks/randomized_benchmarking/clifford_rb/__init__.py,sha256=bTDA156LAl7OLGcMec--1nzDrV1XpPRVq3CquTmucgE,677
-iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=q8bHcrVr8EjTuLeOdg3RoeoLaZhmieCd09IvH-tSvYs,18038
+iqm/benchmarks/randomized_benchmarking/clifford_rb/clifford_rb.py,sha256=v8GDsEC3JscZVJXc6ZqfJaaSb1LocdFTSeOcwHxp50Y,18317
 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/interleaved_rb/interleaved_rb.py,sha256=4hBjIXxqy18WKC8hgpCU6T6Vv2cvJu4AImj7QQDqI1k,27956
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=ZekEqI_89nXzGO1vjM-b5Uwwicy59M4fYHXfA-f0MIg,674
-iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=pOEnEtuJ0rMnTq5nZ1obsQ6LOIVlgFcgNGc8CULWz6E,33987
+iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=hAAvuQPmIBELeqLu-d33gIEAKTk57M8EB8vMUQkXXfI,34376
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=_SEJ10FRNM7_CroysT8hCLZTfpm6ZhEIDCY5zPTnhjo,31390
@@ -36,8 +36,8 @@ 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=We1cccz9BKbITYcSlZHdmBGdjMWAa1xNZe5tKP-yh_E,26004
-iqm_benchmarks-2.10.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
-iqm_benchmarks-2.10.dist-info/METADATA,sha256=C5JusUPjsH27GKfP6gT5Y1unrN2SiSh2eD0nVI2-ih4,10171
-iqm_benchmarks-2.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-iqm_benchmarks-2.10.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.10.dist-info/RECORD,,
+iqm_benchmarks-2.12.dist-info/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.12.dist-info/METADATA,sha256=rBsWY6e6O_75H7yPCxbdmtKSWgaQStE5NzajPE63PsU,10171
+iqm_benchmarks-2.12.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+iqm_benchmarks-2.12.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.12.dist-info/RECORD,,