iqm-benchmarks 2.51__py3-none-any.whl → 2.53__py3-none-any.whl

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/optimization/qscore.py

@@ -541,12 +541,12 @@ def qscore_analysis(run: BenchmarkRunResult) -> BenchmarkAnalysisResult:
 
         if success:
             qcvv_logger.info(
-                f"Q-Score = {num_nodes} passed with approximation ratio (Beta) {approximation_ratio:.4f}; Avg MaxCut size: {np.mean(cut_sizes_list):.4f}"
+                f"Q-Score = {num_nodes} passed with approximation ratio (Beta) {approximation_ratio:.4f} ± {std_of_approximation_ratio:.4f} with uncertainty; Avg MaxCut size: {np.mean(cut_sizes_list):.4f}"
             )
             qscore = num_nodes
         else:
             qcvv_logger.info(
-                f"Q-Score = {num_nodes} failed with approximation ratio (Beta) {approximation_ratio:.4f} < 0.2; Avg MaxCut size: {np.mean(cut_sizes_list):.4f}"
+                f"Q-Score = {num_nodes} failed with approximation ratio (Beta) {approximation_ratio:.4f} ± {std_of_approximation_ratio:.4f} < 0.2; Avg MaxCut size: {np.mean(cut_sizes_list):.4f}"
             )
         qubit_indices = dataset.attrs[num_nodes]["qubit_set"][0]
         observations.extend(
@@ -726,31 +726,40 @@ class QScoreBenchmark(Benchmark):
 
     def generate_maxcut_ansatz_star(  # pylint: disable=too-many-branches
         self,
-        graph,
-        theta,
+        graph: Graph,
+        theta: list[float],
+        qubit_set: Optional[list[int]] = None,
     ):
         """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
+            qubit_set (list[int]): the qubit set to be used for the ansatz
 
         Returns:
             QuantumCircuit: the QAOA ansatz quantum circuit.
         """
-
         gamma = theta[: self.num_qaoa_layers]
         beta = theta[self.num_qaoa_layers :]
-
+        if qubit_set is None:
+            qubit_set_resonator = list(range(self.graph_physical.number_of_nodes() + 1))
+            qubit_set_resonator = [q + 1 for q in qubit_set_resonator]
+        else:
+            qubit_set_resonator = [q + 1 for q in qubit_set]
         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.node_to_qubit = {
+                node: qubit_set_resonator[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
+            self.node_to_qubit = {
+                node: qubit_set_resonator[node] for node in list(self.graph_physical.nodes)
+            }  # no relabeling
+            self.qubit_to_node = {node: node for node in list(self.graph_physical.nodes)}
 
         covermap = self.greedy_vertex_cover_with_mapping(self.graph_physical)
         new_covermap = {}
@@ -759,20 +768,22 @@ class QScoreBenchmark(Benchmark):
         covermap = new_covermap
 
         compr = QuantumRegister(1, "compr")
-        q = QuantumRegister(num_qubits, "q")
+        q = QuantumRegister(self.backend.num_qubits, "q")
         c = ClassicalRegister(num_qubits, "c")
-        qaoa_qc = IQMCircuit(compr, q, c)  # num_qb+1,num_qb)
+        qaoa_qc = IQMCircuit(compr, q, c)
+        qubit_list = list(self.node_to_qubit.values())
+
         # in case the graph is trivial: return empty circuit
         if num_qubits == 0:
             return QuantumCircuit(1)
-        for i in range(1, num_qubits + 1):
+        for i in qubit_list:
             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)
+                qaoa_qc.move(move_qubit, 0)
                 for edge_qubit in edge_qubits:
-                    qaoa_qc.rzz(2 * gamma[layer], 0, edge_qubit + 1)
-                qaoa_qc.move(move_qubit + 1, 0)
+                    qaoa_qc.rzz(2 * gamma[layer], 0, edge_qubit)
+                qaoa_qc.move(move_qubit, 0)
 
             # include edges of the virtual node as rz terms
             for vn in self.virtual_nodes:
@@ -784,13 +795,13 @@ class QScoreBenchmark(Benchmark):
                         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)
+                        qaoa_qc.rz(sign * 2.0 * gamma[layer], self.node_to_qubit[edge[1]])
 
-            for i in range(1, num_qubits + 1):
+            for i in qubit_list:
                 qaoa_qc.rx(2 * beta[layer], i)
-        qaoa_qc.barrier()
-        qaoa_qc.measure(q, c)
 
+        qaoa_qc.barrier()
+        qaoa_qc.measure(qubit_list, list(range(num_qubits)))
         return qaoa_qc
 
     def generate_maxcut_ansatz(  # pylint: disable=too-many-branches
@@ -923,8 +934,6 @@ class QScoreBenchmark(Benchmark):
         dataset = xr.Dataset()
         self.add_all_meta_to_dataset(dataset)
 
-        nqubits = self.backend.num_qubits
-
         if self.choose_qubits_routine == "custom":
             if self.use_virtual_node:
                 node_numbers = [len(qubit_layout) + 1 for qubit_layout in self.custom_qubits_array]
@@ -932,11 +941,8 @@ class QScoreBenchmark(Benchmark):
                 node_numbers = [len(qubit_layout) for qubit_layout in self.custom_qubits_array]
 
         else:
-            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
+            if self.use_virtual_node:  ## if nqubits are used then with virtual node, max_num_nodes is nqubits + 1
+                max_num_nodes = self.max_num_nodes + 1
             else:
                 max_num_nodes = self.max_num_nodes
             node_numbers = list(range(self.min_num_nodes, max_num_nodes + 1))
@@ -1031,24 +1037,29 @@ class QScoreBenchmark(Benchmark):
                 else:
                     theta = get_optimal_angles(self.num_qaoa_layers)
 
-                theta_list.append(theta)
-
                 if self.backend.has_resonators():
-                    qc_opt = self.generate_maxcut_ansatz_star(graph, theta)
+                    qc_opt = self.generate_maxcut_ansatz_star(graph, theta, active_qubit_set)
                 else:
                     qc_list_temp = []
                     cz_count_temp = []
+                    theta_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)
+                        theta = (
+                            calculate_optimal_angles_for_QAOA_p1(G1_permuted)
+                            if G1_permuted.number_of_edges() != 0
+                            else [1.0, 1.0]
+                        )
                         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)
+                        theta_temp.append(theta)
                     min_cz_index = cz_count_temp.index(min(cz_count_temp))
                     qc_opt = qc_list_temp[min_cz_index]
+                    theta_list.append(theta_temp[min_cz_index])
 
                 if len(qc_opt.count_ops()) != 0:
                     qc_list.append(qc_opt)
@@ -1144,7 +1155,6 @@ class QScoreConfiguration(BenchmarkConfigurationBase):
         min_num_nodes (int): The min number of nodes to be taken into account, which should be >= 2.
                             * Default is 2.
         max_num_nodes (int): The max number of nodes to be taken into account, which has to be <= num_qubits + 1.
-                            * Default is None
         use_virtual_node (bool): Parameter to increase the potential Qscore by +1.
                             * Default is True.
         use_classically_optimized_angles (bool): Use pre-optimised tuned parameters in the QAOA circuit.
@@ -1174,7 +1184,7 @@ class QScoreConfiguration(BenchmarkConfigurationBase):
     num_instances: int
     num_qaoa_layers: int = 1
     min_num_nodes: int = 2
-    max_num_nodes: Optional[int] = None
+    max_num_nodes: int
     use_virtual_node: bool = True
     use_classically_optimized_angles: bool = True
     choose_qubits_routine: Literal["naive", "custom"] = "naive"

{iqm_benchmarks-2.51.dist-info → iqm_benchmarks-2.53.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iqm-benchmarks
-Version: 2.51
+Version: 2.53
 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.51.dist-info → iqm_benchmarks-2.53.dist-info}/RECORD

@@ -13,10 +13,10 @@ iqm/benchmarks/compressive_gst/__init__.py,sha256=LneifgYXtcwo2jcXo7GdUEHL6_peip
 iqm/benchmarks/compressive_gst/compressive_gst.py,sha256=_thQfc9qmIJqAcS3Kg4ITEYl8Ofi8xgC_oZotrmyzVk,28484
 iqm/benchmarks/compressive_gst/gst_analysis.py,sha256=H6EQGbpI_sig69Jy6hflg6alMTtjB0t9tHftygzA2YA,41240
 iqm/benchmarks/entanglement/__init__.py,sha256=sHVVToRWRCz0LSntk1rQaoSNNeyZLPoiTjUKWZWrk1E,778
-iqm/benchmarks/entanglement/ghz.py,sha256=bM0bqKnyyT3gnN4QNQfzOS8lXp7bqo1pNlUfo4LK3ug,41586
+iqm/benchmarks/entanglement/ghz.py,sha256=drTmV2JQi9ZYr2_Gl28aizFDbV4TQ2NYynsRou-6re0,45946
 iqm/benchmarks/entanglement/graph_states.py,sha256=6qACedd3UXpiowXc9GW4QhSwO-CzHXnBA3dIC6nCIbE,62788
 iqm/benchmarks/optimization/__init__.py,sha256=_ajW_OibYLCtzU5AUv5c2zuuVYn8ZNeZUcUUSIGt51M,747
-iqm/benchmarks/optimization/qscore.py,sha256=iDbL9aKR-fgw1kQA7cdjkEjwKW6ySufs9kexXgzxwMk,46058
+iqm/benchmarks/optimization/qscore.py,sha256=7JJIVrJvmec77kSdwM4YkwJJoNBCT-LuZ7Ay8JMZ7Nc,46847
 iqm/benchmarks/quantum_volume/__init__.py,sha256=i-Q4SpDWELBw7frXnxm1j4wJRcxbIyrS5uEK_v06YHo,951
 iqm/benchmarks/quantum_volume/clops.py,sha256=EUtO-_OYBYvwqb4xY3aubI2gc2Z6cBokRzt_E0608WA,31242
 iqm/benchmarks/quantum_volume/quantum_volume.py,sha256=af9C4SdEPcYyZgQgtJYy2h_F8QWv1a0hEtN6hr4KeM0,36861
@@ -35,7 +35,7 @@ iqm/benchmarks/randomized_benchmarking/interleaved_rb/__init__.py,sha256=sq6MgN_
 iqm/benchmarks/randomized_benchmarking/interleaved_rb/interleaved_rb.py,sha256=OHoAWajCE48dRDInwQUT8VvtzKad0ExefdqvZFTaYzs,28918
 iqm/benchmarks/randomized_benchmarking/mirror_rb/__init__.py,sha256=jRKbivWCZ3xdO1k0sx-ygC3s5DUkGSModd975PoAtcg,692
 iqm/benchmarks/randomized_benchmarking/mirror_rb/mirror_rb.py,sha256=ijieNymik3BeEUpXS-m64mtgdHz9iAFELuLooHeZY0E,33252
-iqm_benchmarks-2.51.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
+iqm_benchmarks-2.53.dist-info/licenses/LICENSE,sha256=2Ncb40-hqkTil78RPv3-YiJfKaJ8te9USJgliKqIdSY,11558
 mGST/LICENSE,sha256=TtHNq55cUcbglb7uhVudeBLUh_qPdUoAEvU0BBwFz-k,1098
 mGST/README.md,sha256=v_5kw253csHF4-RfE-44KqFmBXIsSMRmOtN0AUPrRxE,5050
 mGST/additional_fns.py,sha256=MV0Pm5ap59IjhT_E3QhsZyM7lXOF1RZ9SD11zoaf43A,31781
@@ -46,7 +46,7 @@ mGST/optimization.py,sha256=x9tJ9wMQ5aONWpNpBMVtK0rwE6DRcOU33htNgrt0tx4,11015
 mGST/qiskit_interface.py,sha256=uCdn-Q9CXI2f4FQSxGUy8GmmzQhr9NhCOFb2VPj0gTs,10061
 mGST/reporting/figure_gen.py,sha256=xFPAHx1Trdqz7swn0kRqwc_jbRaNxhG9Nvx0jeitooo,25847
 mGST/reporting/reporting.py,sha256=Wss1-zFsMEhzrrXKfP-RICau80ezjDIzcN555KhSehc,34160
-iqm_benchmarks-2.51.dist-info/METADATA,sha256=jVyI05sFKgiBDmFwkfhIfoB-HT4gHIf9CDv7s4dRFvM,10968
-iqm_benchmarks-2.51.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-iqm_benchmarks-2.51.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
-iqm_benchmarks-2.51.dist-info/RECORD,,
+iqm_benchmarks-2.53.dist-info/METADATA,sha256=xEhFw6S0jM8KgTwQklUI9RvWzw6W3oQypPMpMue4-80,10968
+iqm_benchmarks-2.53.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+iqm_benchmarks-2.53.dist-info/top_level.txt,sha256=3G23Z-1LGf-IOzTCUl6QwWqiQ3USz25Zt90Ihq192to,9
+iqm_benchmarks-2.53.dist-info/RECORD,,