iqm-benchmarks 2.50__tar.gz → 2.52__tar.gz

{iqm_benchmarks-2.50 → iqm_benchmarks-2.52}/CHANGELOG.rst

@@ -2,6 +2,14 @@
 Changelog
 =========
 
+Version 2.52
+============
+* Circuit transpilation improvements for GHZ benchmark implemented.
+
+Version 2.51
+============
+* Circuit transpilation improvements for Q-score implemented.
+
 Version 2.50
 ============
 * Update iqm-client and iqm-station-control-client dependency versions as part of IQM OS 4.3 release.

{iqm_benchmarks-2.50/src/iqm_benchmarks.egg-info → iqm_benchmarks-2.52}/PKG-INFO

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

{iqm_benchmarks-2.50 → iqm_benchmarks-2.52}/src/iqm/benchmarks/entanglement/ghz.py

@@ -25,7 +25,7 @@ import matplotlib.pyplot as plt
 import networkx
 from networkx import Graph, all_pairs_shortest_path, is_connected, minimum_spanning_tree
 import numpy as np
-from qiskit import QuantumRegister
+from qiskit import ClassicalRegister, QuantumRegister
 from qiskit.quantum_info import random_clifford
 from qiskit.transpiler import CouplingMap
 from qiskit_aer import Aer
@@ -55,6 +55,7 @@ from iqm.benchmarks.utils import (
     xrvariable_to_counts,
 )
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
+from iqm.qiskit_iqm import transpile_to_IQM
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -304,6 +305,74 @@ def generate_ghz_log_cruz(num_qubits: int) -> QuantumCircuit:
     return qc
 
 
+## can introduce another fucntion to time order here CZ and pick the best MOVE qubit.
+
+
+def generate_ghz_star_optimal(
+    qubit_layout: List[int], cal_url: str, backend: IQMBackendBase, inv: bool = False
+) -> QuantumCircuit:
+    """
+    Generates the circuit for creating a GHZ state by maximizing the number of CZ gates between a pair of MOVE gates.
+
+    Args:
+        qubit_layout: List[int]
+            The layout of qubits for the GHZ state.
+        cal_url: str
+            The calibration URL for extracting fidelities.
+        backend: IQMBackendBase
+            The backend to be used for the quantum circuit.
+        inv: bool
+            Whether to generate the inverse circuit.
+
+    Returns:
+        QuantumCircuit: A quantum circuit generating a GHZ state on a given number of qubits.
+    """
+    num_qubits = len(qubit_layout)
+
+    # Initialize quantum and classical registers
+    comp_r = QuantumRegister(1, "comp_r")  # Computational resonator
+    q = QuantumRegister(backend.num_qubits, "q")  # Qubits
+    c = ClassicalRegister(num_qubits, "c")
+    qc = QuantumCircuit(comp_r, q, c, name="GHZ_star_optimal")
+
+    cal_data = extract_fidelities(cal_url, all_metrics=True)
+    # Determine the best move qubit
+    move_dict = {q + 1: cal_data[1][q] for q in qubit_layout}  ## +1 to match qubit indexing in cal data
+    best_move = max(move_dict, key=move_dict.get)
+
+    T2 = cal_data[-1]["t2_echo_time"]
+    t2_dict = {qubit + 1: T2[qubit + 1] for qubit in qubit_layout}  ## +1 to match qubit indexing in cal data
+    cz_order = dict(sorted(t2_dict.items(), key=lambda item: item[1], reverse=True))
+    qubits_to_measure = list(cz_order.keys())
+    cz_order.pop(best_move)
+
+    # Construct the quantum circuit
+    qc.h(best_move)
+    qc.move(best_move, 0)
+    for qubit in cz_order.keys():
+        qc.cx(0, qubit)
+        qc.barrier()
+    qc.move(best_move, 0)
+    qc.barrier()
+    qc.measure(sorted(qubits_to_measure), list(range(num_qubits)))
+
+    if inv:
+        comp_r = QuantumRegister(1, "comp_r")  # Computational resonator
+        q = QuantumRegister(backend.num_qubits, "q")  # Qubits
+        c = ClassicalRegister(num_qubits, "c")
+        qc = QuantumCircuit(comp_r, q, c, name="GHZ_star_optimal_inv")
+
+        qc.move(best_move, 0)
+        for qubit in reversed(cz_order.keys()):
+            qc.cx(0, qubit)
+            qc.barrier()
+        qc.move(best_move, 0)
+        qc.h(best_move)
+        qc.barrier()
+
+    return qc
+
+
 def generate_ghz_star(num_qubits: int) -> QuantumCircuit:
     """
     Generates the circuit for creating a GHZ state by maximizing the number of CZ gates between a pair of MOVE gates.
@@ -648,7 +717,20 @@ class GHZBenchmark(Benchmark):
                 optimize_sqg=self.optimize_sqg,
             )
             final_ghz = ghz_native_transpiled
-
+        elif routine == "star_optimal":
+            if self.cal_url is None:
+                raise ValueError("Calibration URL must be provided for 'star_optimal' routine.")
+            ghz = generate_ghz_star_optimal(qubit_layout, self.cal_url, self.backend)
+            circuit_group.add_circuit(ghz)
+            ghz_native_transpiled = transpile_to_IQM(
+                ghz,
+                self.backend,
+                existing_moves_handling=True,
+                perform_move_routing=False,
+                optimize_single_qubits=self.optimize_sqg,
+                optimization_level=self.qiskit_optim_level,
+            )
+            final_ghz = [ghz_native_transpiled]
         else:
             ghz_log = [generate_ghz_log_cruz(qubit_count), generate_ghz_log_mooney(qubit_count)]
             ghz_native_transpiled, _ = perform_backend_transpilation(
@@ -691,27 +773,54 @@ class GHZBenchmark(Benchmark):
 
         qc = qc_list[0].copy()
         qc.remove_final_measurements()
-        qc_inv = qc.inverse()
         phases = [np.pi * i / (qubit_count + 1) for i in range(2 * qubit_count + 2)]
-        for phase in phases:
-            qc_phase = qc.copy()
-            qc_phase.barrier()
-            for qubit, _ in enumerate(qubit_layout):
-                qc_phase.p(phase, qubit)
-            qc_phase.barrier()
-            qc_phase.compose(qc_inv, inplace=True)
-            qc_phase.measure_active()
-            qc_list.append(qc_phase)
+        if self.state_generation_routine == "star_optimal":
+            qc_inv = generate_ghz_star_optimal(qubit_layout, self.cal_url, self.backend, inv=True)
+            for phase in phases:
+                qc_phase = qc.copy()
+                qc_phase.barrier()
+                for _, qubit in enumerate(qubit_layout):
+                    qc_phase.p(phase, qubit + 1)
+                qc_phase.barrier()
+                qc_phase.compose(qc_inv, inplace=True)
+                qc_phase.measure([q + 1 for q in qubit_layout], list(range(qubit_count)))
+                qc_list.append(qc_phase)
+        else:
+            qc_inv = qc.inverse()
+            for phase in phases:
+                qc_phase = qc.copy()
+                qc_phase.barrier()
+                for qubit, _ in enumerate(qubit_layout):
+                    qc_phase.p(phase, qubit)
+                qc_phase.barrier()
+                qc_phase.compose(qc_inv, inplace=True)
+                qc_phase.measure_active()
+                qc_list.append(qc_phase)
 
         fixed_coupling_map = set_coupling_map(qubit_layout, self.backend, "fixed")
-        qc_list_transpiled, _ = perform_backend_transpilation(
-            qc_list,
-            self.backend,
-            qubit_layout,
-            fixed_coupling_map,
-            qiskit_optim_level=self.qiskit_optim_level,
-            optimize_sqg=self.optimize_sqg,
-        )
+
+        if self.state_generation_routine == "star_optimal":
+            qc_list_transpiled = [
+                transpile_to_IQM(
+                    ghz,
+                    self.backend,
+                    existing_moves_handling=True,
+                    perform_move_routing=False,
+                    optimize_single_qubits=self.optimize_sqg,
+                    optimization_level=self.qiskit_optim_level,
+                )
+                for ghz in qc_list
+            ]
+
+        else:
+            qc_list_transpiled, _ = perform_backend_transpilation(
+                qc_list,
+                self.backend,
+                qubit_layout,
+                fixed_coupling_map,
+                qiskit_optim_level=self.qiskit_optim_level,
+                optimize_sqg=self.optimize_sqg,
+            )
         circuit_group = CircuitGroup(name=idx, circuits=qc_list)
         self.circuits["untranspiled_circuits"].circuit_groups.append(circuit_group)
         return qc_list_transpiled
@@ -791,7 +900,6 @@ class GHZBenchmark(Benchmark):
         transpiled_ghz_group: CircuitGroup = self.generate_native_ghz(
             qubit_layout, qubit_count, self.state_generation_routine
         )
-
         match self.fidelity_routine:
             case "randomized_measurements":
                 all_circuits_list, _ = self.append_rms(cast(int, self.num_RMs), qubit_layout)

{iqm_benchmarks-2.50 → iqm_benchmarks-2.52}/src/iqm/benchmarks/optimization/qscore.py

@@ -1,5 +1,6 @@
+# pylint: disable=too-many-lines
 """
-Qscore benchmark
+This module contains functions and classes for the Qscore benchmarking process.
 """
 
 import itertools
@@ -12,7 +13,8 @@ import matplotlib.pyplot as plt
 from networkx import Graph
 import networkx as nx
 import numpy as np
-from qiskit import QuantumCircuit
+from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
+from qiskit.circuit.library import RZZGate
 from scipy.optimize import basinhopping, minimize
 import xarray as xr
 
@@ -34,6 +36,8 @@ from iqm.benchmarks.utils import (  # execute_with_dd,
     submit_execute,
     xrvariable_to_counts,
 )
+from iqm.iqm_client.transpile import ExistingMoveHandlingOptions
+from iqm.qiskit_iqm import IQMCircuit, transpile_to_IQM
 from iqm.qiskit_iqm.iqm_backend import IQMBackendBase
 
 
@@ -195,7 +199,7 @@ def get_optimal_angles(num_layers: int) -> List[float]:
     # "The fixed angle conjecture for QAOA on regular MaxCut graphs."
     # arXiv preprint arXiv:2107.00677 (2021).
 
-    OPTIMAL_INITIAL_ANGLES = {
+    OPTIMAL_INITIAL_ANGLES = {  # pylint: disable=undefined-variable
         "1": [-0.616, 0.393 / 2],
         "2": [-0.488, 0.898 / 2, 0.555 / 2, 0.293 / 2],
         "3": [-0.422, 0.798 / 2, 0.937 / 2, 0.609 / 2, 0.459 / 2, 0.235 / 2],
@@ -323,6 +327,76 @@ def get_optimal_angles(num_layers: int) -> List[float]:
     return OPTIMAL_INITIAL_ANGLES[str(num_layers)]
 
 
+def group_rzz_gates(circuit: QuantumCircuit):
+    """
+    Extract and group commuting RZZ gates so that gates sharing a qubit
+    are placed next to each other.
+
+    Args:
+        circuit: QuantumCircuit containing RZZ gates.
+
+    Returns:
+        grouped_rzz: list of tuples (instr, [q0_idx, q1_idx])
+                     in reordered grouping.
+    """
+    # Collect RZZ gates as (gate_pos, instr, [q0, q1])
+    rzz_entries = []
+    for pos, (instr, qargs, _) in enumerate(circuit.data):
+        if isinstance(instr, RZZGate) or getattr(instr, "name", "") == "rzz":
+            qidxs = [circuit.find_bit(q).index for q in qargs]
+            rzz_entries.append((pos, instr, qidxs))
+
+    if not rzz_entries:
+        return []
+
+    # Build bipartite graph: gate nodes <-> qubit nodes
+    B = nx.Graph()
+    for gate_pos, instr, qidxs in rzz_entries:
+        gnode = f"g{gate_pos}"
+        B.add_node(gnode, kind="gate", instr=instr, qidxs=qidxs)
+        for q in qidxs:
+            qnode = f"q{q}"
+            B.add_node(qnode, kind="qubit", qidx=q)
+            B.add_edge(gnode, qnode)
+
+    grouped_rzz = []
+
+    # Repeatedly pick the hub qubit with the most RZZs
+    while True:
+        qubit_nodes = [n for n, d in B.nodes(data=True) if d["kind"] == "qubit"]
+        if not qubit_nodes:
+            break
+
+        # Pick hub: max degree, tie-break by smallest index
+        hub = max(qubit_nodes, key=lambda q: (B.degree(q), -int(q[1:])))
+        hub_idx = int(hub[1:])
+
+        # Gates connected to hub
+        connected_gates = [nbr for nbr in B.neighbors(hub) if nbr.startswith("g")]
+        if not connected_gates:
+            B.remove_node(hub)
+            continue
+
+        # Sort gates: prioritize partner qubits with higher degree
+        def sort_key(g):
+            qidxs = B.nodes[g]["qidxs"]
+            other = [q for q in qidxs if q != hub_idx][0]
+            return (-B.degree(f"q{other}"), other)
+
+        connected_gates.sort(key=sort_key)
+
+        # Append in chosen order
+        for g in connected_gates:
+            data = B.nodes[g]
+            grouped_rzz.append((data["qidxs"]))
+            B.remove_node(g)
+
+        # Remove hub itself
+        B.remove_node(hub)
+
+    return grouped_rzz
+
+
 def plot_approximation_ratios(
     nodes: list[int],
     beta_ratio: list[float],
@@ -369,7 +443,7 @@ def plot_approximation_ratios(
     ax.set_ylabel(r"Q-score ratio $\beta(n)$")
     ax.set_xlabel("Number of nodes $(n)$")
     plt.xticks(range(min(nodes), max(nodes) + 1))
-    plt.legend(loc="lower right")
+    plt.legend(loc="upper right")
     plt.grid(True)
 
     if use_virtual_node and use_classically_optimized_angles:
@@ -600,6 +674,7 @@ class QScoreBenchmark(Benchmark):
         self.session_timestamp = strftime("%Y%m%d-%H%M%S")
         self.execution_timestamp = ""
         self.seed = configuration.seed
+        self.num_trials = configuration.num_trials
 
         self.graph_physical: Graph
         self.virtual_nodes: List[Tuple[int, int]]
@@ -622,10 +697,107 @@ class QScoreBenchmark(Benchmark):
                 list(x) for x in cast(Sequence[Sequence[int]], configuration.custom_qubits_array)
             ]
 
+    def greedy_vertex_cover_with_mapping(self, G: nx.Graph):
+        """
+        Approximate a minimum vertex cover for a given graph, providing a mapping of nodes to the edges they cover.
+
+        Args:
+            G (nx.Graph): The input graph for which the vertex cover is to be computed.
+
+        Returns:
+            dict: A dictionary where keys are nodes and values are lists of edges that each node covers.
+        """
+
+        G = G.copy()
+        cover_map = {}
+
+        while G.number_of_edges() > 0:
+            # Pick node with max degree
+            node = max(G.degree, key=lambda x: x[1])[0]
+
+            # Collect neighbors (unique)
+            neighbors = list(G.neighbors(node))
+            cover_map[node] = neighbors
+
+            # Remove node (and incident edges)
+            G.remove_node(node)
+
+        return cover_map
+
+    def generate_maxcut_ansatz_star(  # pylint: disable=too-many-branches
+        self,
+        graph,
+        theta,
+    ):
+        """Generate an ansatz circuit for QAOA MaxCut, with measurements at the end.
+
+        Args:
+            graph (networkx graph): the MaxCut problem graph
+            theta (list[float]): the variational parameters for QAOA, first gammas then betas
+
+        Returns:
+            QuantumCircuit: the QAOA ansatz quantum circuit.
+        """
+
+        gamma = theta[: self.num_qaoa_layers]
+        beta = theta[self.num_qaoa_layers :]
+
+        if self.graph_physical.number_of_nodes() != graph.number_of_nodes():
+            num_qubits = self.graph_physical.number_of_nodes()
+            # re-label the nodes to be between 0 and _num_qubits
+            self.node_to_qubit = {node: qubit for qubit, node in enumerate(list(self.graph_physical.nodes))}
+            self.qubit_to_node = dict(enumerate(list(self.graph_physical.nodes)))
+        else:
+            num_qubits = graph.number_of_nodes()
+            self.node_to_qubit = {node: node for node in list(self.graph_physical.nodes)}  # no relabeling
+            self.qubit_to_node = self.node_to_qubit
+
+        covermap = self.greedy_vertex_cover_with_mapping(self.graph_physical)
+        new_covermap = {}
+        for key, value in covermap.items():
+            new_covermap[self.node_to_qubit[key]] = [self.node_to_qubit[i] for i in value]
+        covermap = new_covermap
+
+        compr = QuantumRegister(1, "compr")
+        q = QuantumRegister(num_qubits, "q")
+        c = ClassicalRegister(num_qubits, "c")
+        qaoa_qc = IQMCircuit(compr, q, c)  # num_qb+1,num_qb)
+        # in case the graph is trivial: return empty circuit
+        if num_qubits == 0:
+            return QuantumCircuit(1)
+        for i in range(1, num_qubits + 1):
+            qaoa_qc.h(i)
+        for layer in range(self.num_qaoa_layers):
+            for move_qubit, edge_qubits in covermap.items():
+                qaoa_qc.move(move_qubit + 1, 0)
+                for edge_qubit in edge_qubits:
+                    qaoa_qc.rzz(2 * gamma[layer], 0, edge_qubit + 1)
+                qaoa_qc.move(move_qubit + 1, 0)
+
+            # include edges of the virtual node as rz terms
+            for vn in self.virtual_nodes:
+                for edge in graph.edges(vn[0]):
+                    # exclude edges between virtual nodes
+                    edges_between_virtual_nodes = list(itertools.combinations([i[0] for i in self.virtual_nodes], 2))
+                    if set(edge) not in list(map(set, edges_between_virtual_nodes)):
+                        # The value of the fixed node defines the sign of the rz gate
+                        sign = 1.0
+                        if vn[1] == 1:
+                            sign = -1.0
+                        qaoa_qc.rz(sign * 2.0 * gamma[layer], self.node_to_qubit[edge[1]] + 1)
+
+            for i in range(1, num_qubits + 1):
+                qaoa_qc.rx(2 * beta[layer], i)
+        qaoa_qc.barrier()
+        qaoa_qc.measure(q, c)
+
+        return qaoa_qc
+
     def generate_maxcut_ansatz(  # pylint: disable=too-many-branches
         self,
         graph: Graph,
         theta: list[float],
+        rzz_list=None,
     ) -> QuantumCircuit:
         """Generate an ansatz circuit for QAOA MaxCut, with measurements at the end.
 
@@ -656,10 +828,14 @@ class QScoreBenchmark(Benchmark):
         for i in range(0, num_qubits):
             qaoa_qc.h(i)
         for layer in range(self.num_qaoa_layers):
-            for edge in self.graph_physical.edges():
-                i = self.node_to_qubit[edge[0]]
-                j = self.node_to_qubit[edge[1]]
-                qaoa_qc.rzz(2 * gamma[layer], i, j)
+            if rzz_list is not None and layer == 0:
+                for rzzs in rzz_list:
+                    qaoa_qc.rzz(2 * gamma[layer], rzzs[0], rzzs[1])
+            else:
+                for edge in self.graph_physical.edges():
+                    i = self.node_to_qubit[edge[0]]
+                    j = self.node_to_qubit[edge[1]]
+                    qaoa_qc.rzz(2 * gamma[layer], i, j)
 
             # include edges of the virtual node as rz terms
             for vn in self.virtual_nodes:
@@ -792,6 +968,33 @@ class QScoreBenchmark(Benchmark):
             no_edge_instances = []
             qc_all = []  # all circuits, including those with no edges
             start_seed = seed
+
+            # Choose the qubit layout
+            if self.choose_qubits_routine.lower() == "naive":
+                qubit_set = self.choose_qubits_naive(updated_num_nodes)
+            elif self.choose_qubits_routine.lower() == "custom" or self.choose_qubits_routine.lower() == "mapomatic":
+                qubit_set = self.choose_qubits_custom(updated_num_nodes)
+            else:
+                raise ValueError('choose_qubits_routine must either be "naive" or "custom".')
+            qubit_set_list.append(qubit_set)
+
+            qcvv_logger.setLevel(logging.WARNING)
+            if self.choose_qubits_routine == "naive":
+                active_qubit_set = None
+                effective_coupling_map = self.backend.coupling_map
+            else:
+                active_qubit_set = qubit_set
+                effective_coupling_map = self.backend.coupling_map.reduce(active_qubit_set)
+
+            transpilation_params = {
+                "backend": self.backend,
+                "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,
+            }
+
             for instance in range(self.num_instances):
                 qcvv_logger.debug(f"Executing graph {instance} with {num_nodes} nodes.")
                 graph = nx.generators.erdos_renyi_graph(num_nodes, 0.5, seed=seed)
@@ -820,17 +1023,6 @@ class QScoreBenchmark(Benchmark):
                     no_edge_instances.append(instance)
                     qcvv_logger.debug(f"Graph {instance+1}/{self.num_instances} had no edges: cut size = 0.")
 
-                # Choose the qubit layout
-                if self.choose_qubits_routine.lower() == "naive":
-                    qubit_set = self.choose_qubits_naive(updated_num_nodes)
-                elif (
-                    self.choose_qubits_routine.lower() == "custom" or self.choose_qubits_routine.lower() == "mapomatic"
-                ):
-                    qubit_set = self.choose_qubits_custom(updated_num_nodes)
-                else:
-                    raise ValueError('choose_qubits_routine must either be "naive" or "custom".')
-                qubit_set_list.append(qubit_set)
-
                 if self.use_classically_optimized_angles:
                     if graph.number_of_edges() != 0:
                         theta = calculate_optimal_angles_for_QAOA_p1(graph)
@@ -841,11 +1033,26 @@ class QScoreBenchmark(Benchmark):
 
                 theta_list.append(theta)
 
-                qc = self.generate_maxcut_ansatz(graph, theta)
-
-                if len(qc.count_ops()) != 0:
-                    qc_list.append(qc)
-                    qc_all.append(qc)
+                if self.backend.has_resonators():
+                    qc_opt = self.generate_maxcut_ansatz_star(graph, theta)
+                else:
+                    qc_list_temp = []
+                    cz_count_temp = []
+                    for _ in range(self.num_trials):
+                        perm = np.random.permutation(num_nodes)
+                        mapping = dict(zip(graph.nodes, perm))
+                        G1_permuted = nx.relabel_nodes(graph, mapping)
+                        theta = calculate_optimal_angles_for_QAOA_p1(G1_permuted)
+                        qc_perm = self.generate_maxcut_ansatz(G1_permuted, theta)
+                        transpiled_qc_temp, _ = perform_backend_transpilation([qc_perm], **transpilation_params)
+                        cz_count_temp.append(transpiled_qc_temp[0].count_ops().get("cz", 0))
+                        qc_list_temp.append(qc_perm)
+                    min_cz_index = cz_count_temp.index(min(cz_count_temp))
+                    qc_opt = qc_list_temp[min_cz_index]
+
+                if len(qc_opt.count_ops()) != 0:
+                    qc_list.append(qc_opt)
+                    qc_all.append(qc_opt)
                     qubit_to_node_copy = self.qubit_to_node.copy()
                     qubit_to_node_list.append(qubit_to_node_copy)
                 else:
@@ -855,24 +1062,20 @@ class QScoreBenchmark(Benchmark):
                 seed += 1
                 qcvv_logger.debug(f"Solved the MaxCut on graph {instance+1}/{self.num_instances}.")
 
-            qcvv_logger.setLevel(logging.WARNING)
-            if self.choose_qubits_routine == "naive":
-                active_qubit_set = None
-                effective_coupling_map = self.backend.coupling_map
+            if self.backend.has_resonators():
+                transpiled_qc = [
+                    transpile_to_IQM(
+                        qc,
+                        self.backend,
+                        optimize_single_qubits=self.optimize_sqg,
+                        existing_moves_handling=ExistingMoveHandlingOptions.KEEP,
+                        perform_move_routing=False,
+                        optimization_level=self.qiskit_optim_level,
+                    )
+                    for qc in qc_list
+                ]
             else:
-                active_qubit_set = qubit_set
-                effective_coupling_map = self.backend.coupling_map.reduce(active_qubit_set)
-
-            transpilation_params = {
-                "backend": self.backend,
-                "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,
-            }
-
-            transpiled_qc, _ = perform_backend_transpilation(qc_list, **transpilation_params)
+                transpiled_qc, _ = perform_backend_transpilation(qc_list, **transpilation_params)
 
             sorted_transpiled_qc_list = {tuple(qubit_set): transpiled_qc}
             # Execute on the backend
@@ -892,9 +1095,7 @@ class QScoreBenchmark(Benchmark):
             num_instances_with_edges = len(instance_with_edges)
             if self.REM:
                 counts_retrieved, time_retrieve = retrieve_all_counts(jobs)
-                rem_counts = apply_readout_error_mitigation(
-                    backend, transpiled_qc, counts_retrieved, self.mit_shots
-                )
+                rem_counts = apply_readout_error_mitigation(backend, transpiled_qc, counts_retrieved, self.mit_shots)
                 execution_results.extend(
                     rem_counts[0][instance].nearest_probability_distribution()
                     for instance in range(num_instances_with_edges)
@@ -960,6 +1161,7 @@ class QScoreConfiguration(BenchmarkConfigurationBase):
                             * Default is 3.
         optimize_sqg (bool): Whether Single Qubit Gate Optimization is performed upon transpilation.
                             * Default is True.
+        num_trials (Optional[int]): Number of trials to perform when choosing graph permutations to minimize CZ gates.
         seed (int): The random seed.
                             * Default is 1.
         REM (bool): Use readout error mitigation.
@@ -980,6 +1182,7 @@ class QScoreConfiguration(BenchmarkConfigurationBase):
     custom_qubits_array: Optional[Sequence[Sequence[int]]] = None
     qiskit_optim_level: int = 3
     optimize_sqg: bool = True
+    num_trials: int = 10
     seed: int = 1
     REM: bool = False
     mit_shots: int = 1000

{iqm_benchmarks-2.50 → iqm_benchmarks-2.52/src/iqm_benchmarks.egg-info}/PKG-INFO

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

{iqm_benchmarks-2.50 → iqm_benchmarks-2.52}/tests/test_qscore.py

@@ -7,7 +7,7 @@ from iqm.qiskit_iqm.fake_backends.fake_deneb import IQMFakeDeneb
 
 class TestQScore:
     backend = IQMFakeApollo()
-    custom_qubits_array = [[0, 1, 3], [0, 1, 2, 3], [0, 1, 2, 3, 4]]
+    custom_qubits_array = [[0, 1, 2, 3], [0, 1, 2, 3, 4]]
 
     def test_qscore(self):
         EXAMPLE_QSCORE = QScoreConfiguration(
@@ -15,13 +15,14 @@ class TestQScore:
             num_qaoa_layers=1,
             shots=4,
             calset_id=None,  # calibration set ID, default is None
-            min_num_nodes=3,
+            min_num_nodes=4,
             max_num_nodes=5,
             use_virtual_node=True,
             use_classically_optimized_angles=True,
             choose_qubits_routine="custom",
             custom_qubits_array=self.custom_qubits_array,
-            seed=1,
+            seed=200,
+            num_trials = 2,
             REM=True,
             mit_shots=10,
         )
@@ -32,4 +33,4 @@ class TestQScore:
 
 class TestQScoreDeneb(TestQScore):
     backend = IQMFakeDeneb()
-    custom_qubits_array = [[1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
+    custom_qubits_array = [[1, 2, 3, 4], [1, 2, 3, 4, 5]]