Override classmethod supports_aux_operators in VQEProgram

qiskit_optimization/runtime/vqe_program.py

@@ -222,6 +222,10 @@ def wrapped_callback(*args):
         else:
             return None
 
+    @classmethod
+    def supports_aux_operators(cls) -> bool:
+        return True
+
     def compute_minimum_eigenvalue(
         self, operator: OperatorBase, aux_operators: Optional[List[Optional[OperatorBase]]] = None
     ) -> MinimumEigensolverResult:

test/algorithms/test_min_eigen_optimizer.py

@@ -13,21 +13,22 @@
 """ Test Min Eigen Optimizer """
 
 import unittest
-from test.optimization_test_case import (
-    QiskitOptimizationTestCase,
-    requires_extra_library,
-)
 
 import numpy as np
 from ddt import data, ddt
 from docplex.mp.model import Model
-
 from qiskit import BasicAer
 from qiskit.algorithms import QAOA, VQE, NumPyMinimumEigensolver
 from qiskit.algorithms.optimizers import COBYLA, SPSA
 from qiskit.circuit.library import TwoLocal
+from qiskit.providers.basicaer import QasmSimulatorPy
 from qiskit.utils import QuantumInstance, algorithm_globals
-from qiskit_optimization.algorithms import CplexOptimizer, MinimumEigenOptimizer
+
+from qiskit_optimization.algorithms import (
+    CplexOptimizer,
+    MinimumEigenOptimizer,
+    MinimumEigenOptimizationResult,
+)
 from qiskit_optimization.algorithms.optimization_algorithm import (
     OptimizationResultStatus,
 )
@@ -39,7 +40,13 @@
     QuadraticProgramToQubo,
 )
 from qiskit_optimization.problems import QuadraticProgram
+from qiskit_optimization.runtime import VQEProgram, QAOAProgram
 from qiskit_optimization.translators import from_docplex_mp
+from test.optimization_test_case import (
+    QiskitOptimizationTestCase,
+    requires_extra_library,
+)
+from test.runtime.fake_vqeruntime import FakeRuntimeProvider
 
 
 @ddt
@@ -353,6 +360,48 @@ def test_samples_vqe(self, simulator):
         self.assertAlmostEqual(results.raw_samples[0].fval, opt_sol)
         self.assertEqual(results.raw_samples[0].status, success)
 
+    def test_vqe_program(self):
+        """Test with VQEProgram"""
+        ry_ansatz = TwoLocal(5, "ry", "cz", reps=3, entanglement="full")
+        optimizer = {"name": "SPSA", "maxiter": 100}
+        initial_point = np.random.RandomState(42).random(ry_ansatz.num_parameters)
+        backend = QasmSimulatorPy()
+        provider = FakeRuntimeProvider()
+
+        vqe_program = VQEProgram(
+            ansatz=ry_ansatz,
+            optimizer=optimizer,
+            initial_point=initial_point,
+            backend=backend,
+            provider=provider,
+        )
+
+        vqe = MinimumEigenOptimizer(vqe_program)
+        results = vqe.solve(self.op_ordering)
+
+        self.assertIsInstance(results, MinimumEigenOptimizationResult)
+
+    def test_qaoa_program(self):
+        """Test with QAOAProgram"""
+        optimizer = {"name": "SPSA", "maxiter": 100}
+        reps = 2
+        initial_point = np.random.RandomState(42).random(2 * reps)
+        backend = QasmSimulatorPy()
+        provider = FakeRuntimeProvider()
+
+        qaoa_program = QAOAProgram(
+            optimizer=optimizer,
+            reps=reps,
+            initial_point=initial_point,
+            backend=backend,
+            provider=provider,
+        )
+
+        qaoa = MinimumEigenOptimizer(qaoa_program)
+        results = qaoa.solve(self.op_minimize)
+
+        self.assertIsInstance(results, MinimumEigenOptimizationResult)
+
 
 if __name__ == "__main__":
     unittest.main()