feat: upgrade to qiskit 2.3.0 - update imports, fix bugs, add tests

Co-authored-by: fgfuchs <2428162+fgfuchs@users.noreply.github.com>

Author: Copilot

qaoa/mixers/grover_mixer.py

@@ -32,7 +32,7 @@ def __init__(self, subcircuit: InitialState) -> None:
         self.mixer_param = Parameter("x_beta")
 
     def create_circuit(self):
-        """
+        r"""
         Constructs the Grover mixer circuit using the subcircuit.
 
         Given feasible states f \in F,

qaoa/mixers/maxkcut_grover_mixer.py

@@ -130,6 +130,7 @@ def create_circuit(self) -> None:
             tensor_feas = Tensor(circ_one_node, self.num_V)
 
             gm = Grover(tensor_feas)
+            gm.setNumQubits(tensor_feas.N_qubits)
 
             gm.create_circuit()
             self.circuit = gm.circuit

qaoa/qaoa.py

@@ -13,12 +13,12 @@
 )
 from qiskit.circuit import Parameter
 try:
-    from qiskit.primitives import Sampler
-except ImportError:
     from qiskit_aer.primitives import Sampler
+except ImportError:
+    from qiskit.primitives import StatevectorSampler as Sampler
 from qiskit_algorithms.optimizers import COBYLA
 
-from qiskit_aer import Aer
+from qiskit_aer import AerSimulator, Aer
 
 from qaoa.initialstates import InitialState
 from qaoa.mixers import Mixer
@@ -198,7 +198,7 @@ def __init__(
         problem,
         mixer,
         initialstate,
-        backend=Aer.get_backend("qasm_simulator"),
+        backend=AerSimulator(),
         noisemodel=None,
         optimizer=[COBYLA, {}],  # optimizer, options
         precision=None,

setup.py

@@ -18,9 +18,9 @@
         "matplotlib",
         "networkx",
         "jupyter",
-        "qiskit==1.1.1",
-        "qiskit-aer",
-        "qiskit-algorithms",
+        "qiskit>=2.3.0",
+        "qiskit-aer>=0.17.0",
+        "qiskit-algorithms>=0.4.0",
         "qiskit-finance",
         "pylatexenc",
     ],

unittests/test_multiangle_gridsearch.py

@@ -6,14 +6,14 @@
 sys.path.append("../")
 from qaoa import QAOA
 from qaoa import problems, mixers, initialstates
-from qiskit_aer import Aer
+from qiskit_aer import AerSimulator
 
 
 class TestMultiAngleGridSearch(unittest.TestCase):
     """Test grid search works for both vanilla and multi-angle QAOA."""
 
     def setUp(self):
-        self.backend = Aer.get_backend("qasm_simulator")
+        self.backend = AerSimulator()
         self.angles = {"gamma": [0, 2 * np.pi, 5], "beta": [0, 2 * np.pi, 5]}
 
     def test_vanilla_grid_search_sequential(self):

unittests/test_qiskit2_compatibility.py

@@ -0,0 +1,221 @@
+"""
+Integration tests verifying that the QAOA library works correctly with
+Qiskit >= 2.x.
+
+These tests cover:
+1. Qiskit version verification (>= 2.0)
+2. Correct Sampler import (qiskit.primitives.Sampler was removed in Qiskit 2.x)
+3. End-to-end QAOA optimization on a small MaxCut problem
+4. All key components: problems, mixers, initial states, transpile
+5. Core Qiskit 2.x API elements used by the library
+"""
+
+import unittest
+
+import numpy as np
+import networkx as nx
+
+import qiskit
+
+
+class TestQiskitVersion(unittest.TestCase):
+    """Verify that the installed Qiskit version is >= 2.0."""
+
+    def test_qiskit_version_is_2_or_higher(self):
+        major = int(qiskit.__version__.split(".")[0])
+        self.assertGreaterEqual(
+            major,
+            2,
+            f"Qiskit {qiskit.__version__} is installed, but >= 2.0.0 is required.",
+        )
+
+
+class TestQiskitImports(unittest.TestCase):
+    """Verify that all Qiskit symbols used by the library can be imported."""
+
+    def test_core_qiskit_imports(self):
+        from qiskit import (
+            QuantumCircuit,
+            QuantumRegister,
+            ClassicalRegister,
+            AncillaRegister,
+            transpile,
+        )
+        from qiskit.circuit import Parameter
+        from qiskit.circuit.library import (
+            PhaseGate,
+            RYGate,
+            XXPlusYYGate,
+            PauliEvolutionGate,
+        )
+        from qiskit.quantum_info import SparsePauliOp, Pauli, Statevector
+
+    def test_sampler_import(self):
+        """qiskit.primitives.Sampler was removed in Qiskit 2.x; the fallback
+        to qiskit_aer.primitives.Sampler must work."""
+        try:
+            from qiskit_aer.primitives import Sampler
+        except ImportError:
+            from qiskit.primitives import StatevectorSampler as Sampler
+        self.assertIsNotNone(Sampler)
+
+    def test_aer_simulator_import(self):
+        from qiskit_aer import AerSimulator
+        backend = AerSimulator()
+        self.assertIsNotNone(backend)
+
+    def test_qiskit_algorithms_optimizers(self):
+        from qiskit_algorithms.optimizers import COBYLA, SPSA
+        self.assertIsNotNone(COBYLA)
+        self.assertIsNotNone(SPSA)
+
+    def test_qaoa_package_import(self):
+        import qaoa
+        from qaoa import QAOA
+        from qaoa import problems, mixers, initialstates
+
+
+class TestQAOAEndToEnd(unittest.TestCase):
+    """End-to-end QAOA test on a small MaxCut instance using Qiskit 2.x."""
+
+    def setUp(self):
+        from qiskit_aer import AerSimulator
+        self.backend = AerSimulator()
+        # 3-node path graph: optimal MaxCut = 2
+        self.G = nx.path_graph(3)
+        self.angles = {"gamma": [0, 2 * np.pi, 5], "beta": [0, np.pi, 5]}
+
+    def test_maxcut_optimize_depth1(self):
+        """QAOA at depth 1 should find a positive approximation ratio for MaxCut."""
+        from qaoa import QAOA
+        from qaoa import problems, mixers, initialstates
+
+        problem = problems.MaxCut(self.G)
+        mixer = mixers.X()
+        init = initialstates.Plus()
+
+        qaoa = QAOA(
+            problem,
+            mixer,
+            init,
+            backend=self.backend,
+            shots=512,
+        )
+        qaoa.optimize(depth=1, angles=self.angles)
+
+        best_exp = qaoa.get_Exp(depth=1)
+        # For a path graph with 3 nodes the optimum is -2 (cost stored negated).
+        # A good QAOA should achieve at least -1 (approximation ratio >= 0.5).
+        self.assertLessEqual(best_exp, -1.0)
+
+    def test_circuit_creation_and_transpile(self):
+        """Verify that the parameterised circuit is created and transpiled correctly."""
+        from qaoa import QAOA
+        from qaoa import problems, mixers, initialstates
+        from qiskit import QuantumCircuit
+
+        problem = problems.MaxCut(self.G)
+        mixer = mixers.X()
+        init = initialstates.Plus()
+
+        qaoa = QAOA(
+            problem,
+            mixer,
+            init,
+            backend=self.backend,
+        )
+        qaoa.createParameterizedCircuit(depth=1)
+
+        self.assertIsInstance(qaoa.parameterized_circuit, QuantumCircuit)
+        # After transpilation the circuit should have no free parameters
+        # (they are bound at runtime via parameter_binds).
+        self.assertGreater(len(qaoa.parameterized_circuit.parameters), 0)
+
+    def test_hist_method(self):
+        """The hist() helper should return a non-empty measurement histogram."""
+        from qaoa import QAOA
+        from qaoa import problems, mixers, initialstates
+
+        problem = problems.MaxCut(self.G)
+        qaoa = QAOA(
+            problem,
+            mixers.X(),
+            initialstates.Plus(),
+            backend=self.backend,
+            shots=256,
+        )
+        qaoa.optimize(depth=1, angles=self.angles)
+        angles = qaoa.get_angles(depth=1)
+        hist = qaoa.hist(angles, shots=256)
+
+        self.assertIsInstance(hist, dict)
+        self.assertGreater(len(hist), 0)
+        total_shots = sum(hist.values())
+        self.assertEqual(total_shots, 256)
+
+
+class TestQAOAComponents(unittest.TestCase):
+    """Verify individual QAOA components work with Qiskit 2.x."""
+
+    def _make_graph(self):
+        G = nx.Graph()
+        G.add_nodes_from([0, 1])
+        G.add_weighted_edges_from([(0, 1, 1.0)])
+        return G
+
+    def test_maxcut_problem_circuit(self):
+        from qaoa.problems import MaxCut
+        from qiskit.circuit import QuantumCircuit
+
+        problem = MaxCut(self._make_graph())
+        problem.create_circuit()
+        self.assertIsInstance(problem.circuit, QuantumCircuit)
+        self.assertEqual(len(problem.circuit.parameters), 1)
+
+    def test_x_mixer_circuit(self):
+        from qaoa.mixers import X
+        from qiskit.circuit import QuantumCircuit
+
+        mixer = X()
+        mixer.setNumQubits(2)
+        mixer.create_circuit()
+        self.assertIsInstance(mixer.circuit, QuantumCircuit)
+
+    def test_xy_mixer_circuit(self):
+        from qaoa.mixers import XY
+        from qiskit.circuit import QuantumCircuit
+
+        mixer = XY(topology=[[0, 1]])  # explicit edge topology for 2-qubit ring
+        mixer.setNumQubits(2)
+        mixer.create_circuit()
+        self.assertIsInstance(mixer.circuit, QuantumCircuit)
+
+    def test_plus_initialstate_circuit(self):
+        from qaoa.initialstates import Plus
+        from qiskit.circuit import QuantumCircuit
+
+        init = Plus()
+        init.setNumQubits(2)
+        init.create_circuit()
+        self.assertIsInstance(init.circuit, QuantumCircuit)
+
+    def test_transpile_with_aer_simulator(self):
+        """transpile() should work with AerSimulator in Qiskit 2.x."""
+        from qiskit import QuantumCircuit, transpile
+        from qiskit.circuit import Parameter
+        from qiskit_aer import AerSimulator
+
+        backend = AerSimulator()
+        qc = QuantumCircuit(2, 2)
+        theta = Parameter("theta")
+        qc.h(0)
+        qc.rz(theta, 0)
+        qc.cx(0, 1)
+        qc.measure([0, 1], [0, 1])
+
+        transpiled = transpile(qc, backend)
+        self.assertIsInstance(transpiled, QuantumCircuit)
+
+
+if __name__ == "__main__":
+    unittest.main()