(!) Update qaoa convention, finish migration to qiskit 1.0 in noteboo…

…ks (#18)

qopt_best_practices/qubit_selection/backend_evaluator.py

@@ -20,7 +20,11 @@ class BackendEvaluator:
 
     def __init__(self, backend: Backend):
         self.backend = backend
-        self.coupling_map = CouplingMap(backend.coupling_map)
+        if backend.version == 2:
+            coupling_map = CouplingMap(backend.coupling_map)
+        else:
+            coupling_map = CouplingMap(backend.configuration().coupling_map)
+        self.coupling_map = coupling_map
         if not self.coupling_map.is_symmetric:
             self.coupling_map.make_symmetric()
 

qopt_best_practices/qubit_selection/metric_evaluators.py

@@ -17,26 +17,40 @@ def evaluate_fidelity(path: list[int], backend: Backend, edges: rx.EdgeList) ->
     """
 
     two_qubit_fidelity = {}
-    target = backend.target
 
-    try:
-        gate_name = list(set(TWO_Q_GATES).intersection(backend.operation_names))[0]
-    except IndexError as exc:
-        raise ValueError("Could not identify two-qubit gate") from exc
-
-    for edge in edges:
+    if backend.version == 2:
+        target = backend.target
+        try:
+            gate_name = list(set(TWO_Q_GATES).intersection(backend.operation_names))[0]
+        except IndexError as exc:
+            raise ValueError("Could not identify two-qubit gate") from exc
+
+        for edge in edges:
+            try:
+                cx_error = target[gate_name][edge].error
+            except:  # pylint: disable=bare-except
+                cx_error = target[gate_name][edge[::-1]].error
+
+            two_qubit_fidelity[tuple(edge)] = 1 - cx_error
+    else:
+        props = backend.properties()
         try:
-            cx_error = target[gate_name][edge].error
-        except:  # pylint: disable=bare-except
-            cx_error = target[gate_name][edge[::-1]].error
+            gate_name = list(set(TWO_Q_GATES).intersection(backend.configuration().basis_gates))[0]
+        except IndexError as exc:
+            raise ValueError("Could not identify two-qubit gate") from exc
 
-        two_qubit_fidelity[tuple(edge)] = 1 - cx_error
+        for edge in edges:
+            try:
+                cx_error = props.gate_error(gate_name, edge)
+            except:  # pylint: disable=bare-except
+                cx_error = props.gate_error(gate_name, edge[::-1])
+
+            two_qubit_fidelity[tuple(edge)] = 1 - cx_error
 
     if not path or len(path) == 1:
         return 0.0
 
     fidelity = 1.0
     for idx in range(len(path) - 1):
         fidelity *= two_qubit_fidelity[(path[idx], path[idx + 1])]
-
     return fidelity

qopt_best_practices/qubit_selection/qubit_subset_finders.py

@@ -19,7 +19,11 @@ def find_lines(length: int, backend: Backend) -> list[int]:
         The found paths.
     """
 
-    coupling_map = CouplingMap(backend.coupling_map)
+    if backend.version == 2:
+        coupling_map = CouplingMap(backend.coupling_map)
+    else:
+        coupling_map = CouplingMap(backend.configuration().coupling_map)
+
     if not coupling_map.is_symmetric:
         coupling_map.make_symmetric()
 

qopt_best_practices/swap_strategies/build_circuit.py

@@ -93,7 +93,7 @@ def apply_qaoa_layers(  # pylint: disable=too-many-arguments,too-many-locals
         mixer_layer = mixer
     else:
         mixer_layer = QuantumCircuit(num_qubits)
-        mixer_layer.rx(beta[0], range(num_qubits))
+        mixer_layer.rx(-2 * beta[0], range(num_qubits))
 
     for layer in range(num_layers):
         bind_dict = {cost_layer.parameters[0]: gamma[layer]}

test/test_qubit_selection.py

@@ -4,7 +4,7 @@
 import os
 from unittest import TestCase
 
-from qiskit_ibm_runtime.fake_provider import FakeSherbrooke
+from qiskit_ibm_runtime.fake_provider import FakeSherbrooke, FakeHanoi, FakeHanoiV2
 from qiskit.providers.fake_provider import GenericBackendV2
 
 
@@ -20,26 +20,24 @@ def setUp(self):
 
         # load data
         graph_file = os.path.join(os.path.dirname(__file__), "data/graph_2layers_0seed.json")
-
         with open(graph_file, "r") as file:
             data = json.load(file)
 
+        # 10 qubit graph
         self.mapped_paulis = [tuple(pauli) for pauli in data["paulis"]]
         self.mapped_graph = build_max_cut_graph(self.mapped_paulis)
         self.backend = FakeSherbrooke()
 
     def test_find_lines(self):
         """Test backend evaluation"""
-
         paths = find_lines(len(self.mapped_graph), self.backend)
 
         self.assertEqual(len(paths), 1336)
         self.assertEqual(len(paths[0]), len(self.mapped_graph))
         self.assertIsInstance(paths[0][0], int)
 
     def test_find_lines_directed(self):
-        "Test backend with directed (asymmetric) coupling map"
-
+        """Test backend with directed (asymmetric) coupling map"""
         directed_fake_backend = GenericBackendV2(4, coupling_map=[[0, 1], [1, 2], [3, 2], [3, 0]])
         lines = find_lines(3, backend=directed_fake_backend)
 
@@ -48,11 +46,18 @@ def test_find_lines_directed(self):
 
     def test_qubit_selection(self):
         """Test backend evaluation"""
-
         path_finder = BackendEvaluator(self.backend)
-
         path, _, _ = path_finder.evaluate(len(self.mapped_graph))
 
         expected_path = [45, 46, 47, 48, 49, 55, 68, 69, 70, 74]
-
         self.assertEqual(set(path), set(expected_path))
+
+    def test_qubit_selection_v1_v2(self):
+        """Test backend evaluation for 10 qubit line"""
+        backends = [FakeHanoi(), FakeHanoiV2()]
+
+        for backend in backends:
+            path_finder = BackendEvaluator(backend)
+            path, _, _ = path_finder.evaluate(len(self.mapped_graph))
+            expected_path = [1, 2, 4, 7, 8, 10, 11, 12, 13, 14]
+            self.assertEqual(set(path), set(expected_path))