From 0e0ebac7762b15c031b9fbc837f6d0439b133de6 Mon Sep 17 00:00:00 2001 From: Declan Millar Date: Tue, 27 Sep 2022 12:40:05 +0100 Subject: [PATCH] introduce FilterType and aux_operator_eigenvalues -> aux_operators_evaluated --- .../minimum_eigensolver.py | 15 ++- .../numpy_minimum_eigensolver.py | 12 +-- qiskit/algorithms/minimum_eigensolvers/vqe.py | 18 ++-- .../test_numpy_minimum_eigensolver.py | 100 +++++++++--------- .../minimum_eigensolvers/test_vqe.py | 56 +++++----- 5 files changed, 100 insertions(+), 101 deletions(-) diff --git a/qiskit/algorithms/minimum_eigensolvers/minimum_eigensolver.py b/qiskit/algorithms/minimum_eigensolvers/minimum_eigensolver.py index 017639ab121b..30d3b49ce463 100644 --- a/qiskit/algorithms/minimum_eigensolvers/minimum_eigensolver.py +++ b/qiskit/algorithms/minimum_eigensolvers/minimum_eigensolver.py @@ -15,6 +15,7 @@ from __future__ import annotations from abc import ABC, abstractmethod +from typing import Any from qiskit.opflow import PauliSumOp from qiskit.quantum_info.operators.base_operator import BaseOperator @@ -74,7 +75,7 @@ class MinimumEigensolverResult(AlgorithmResult): def __init__(self) -> None: super().__init__() self._eigenvalue = None - self._aux_operator_eigenvalues = None + self._aux_operators_evaluated = None @property def eigenvalue(self) -> complex | None: @@ -86,15 +87,13 @@ def eigenvalue(self, value: complex) -> None: self._eigenvalue = value @property - def aux_operator_eigenvalues(self) -> ListOrDict[tuple[complex, tuple[complex, int]]] | None: + def aux_operators_evaluated(self) -> ListOrDict[tuple[complex, dict[str, Any]]] | None: """The aux operator expectation values. These values are in fact tuples formatted as (mean, (variance, shots)). """ - return self._aux_operator_eigenvalues + return self._aux_operators_evaluated - @aux_operator_eigenvalues.setter - def aux_operator_eigenvalues( - self, value: ListOrDict[tuple[complex, tuple[complex, int]]] - ) -> None: - self._aux_operator_eigenvalues = value + @aux_operators_evaluated.setter + def aux_operators_evaluated(self, value: ListOrDict[tuple[complex, dict[str, Any]]]) -> None: + self._aux_operators_evaluated = value diff --git a/qiskit/algorithms/minimum_eigensolvers/numpy_minimum_eigensolver.py b/qiskit/algorithms/minimum_eigensolvers/numpy_minimum_eigensolver.py index eb021f926109..3a4acb5375db 100644 --- a/qiskit/algorithms/minimum_eigensolvers/numpy_minimum_eigensolver.py +++ b/qiskit/algorithms/minimum_eigensolvers/numpy_minimum_eigensolver.py @@ -28,6 +28,8 @@ logger = logging.getLogger(__name__) +FilterType = Callable[[list | np.ndarray, float, ListOrDict[float] | None], bool] + class NumPyMinimumEigensolver(MinimumEigensolver): """ @@ -36,9 +38,7 @@ class NumPyMinimumEigensolver(MinimumEigensolver): def __init__( self, - filter_criterion: Callable[ - [list | np.ndarray, float, ListOrDict[float] | None], bool - ] = None, + filter_criterion: FilterType | None = None, ) -> None: """ Args: @@ -54,14 +54,14 @@ def __init__( @property def filter_criterion( self, - ) -> Callable[[list | np.ndarray, float, ListOrDict[float] | None], bool] | None: + ) -> FilterType | None: """Returns the criterion for filtering eigenstates/eigenvalues.""" return self._eigensolver.filter_criterion @filter_criterion.setter def filter_criterion( self, - filter_criterion: Callable[[list | np.ndarray, float, ListOrDict[float] | None], bool], + filter_criterion: FilterType, ) -> None: self._eigensolver.filter_criterion = filter_criterion @@ -81,7 +81,7 @@ def compute_minimum_eigenvalue( result.eigenvalue = eigensolver_result.eigenvalues[0] result.eigenstate = eigensolver_result.eigenstates[0] if eigensolver_result.aux_operator_eigenvalues: - result.aux_operator_eigenvalues = eigensolver_result.aux_operator_eigenvalues[0] + result.aux_operators_evaluated = eigensolver_result.aux_operator_eigenvalues[0] logger.debug("NumPy minimum eigensolver result: %s", result) diff --git a/qiskit/algorithms/minimum_eigensolvers/vqe.py b/qiskit/algorithms/minimum_eigensolvers/vqe.py index 26195b704072..87cbe9e5f4d3 100644 --- a/qiskit/algorithms/minimum_eigensolvers/vqe.py +++ b/qiskit/algorithms/minimum_eigensolvers/vqe.py @@ -182,22 +182,22 @@ def compute_minimum_eigenvalue( fun=evaluate_energy, x0=initial_point, jac=evaluate_gradient, bounds=bounds ) - eval_time = time() - start_time + optimizer_time = time() - start_time logger.info( "Optimization complete in %s seconds.\nFound optimal point %s", - eval_time, + optimizer_time, optimizer_result.x, ) if aux_operators is not None: - aux_values = estimate_observables( + aux_operators_evaluated = estimate_observables( self.estimator, self.ansatz, aux_operators, optimizer_result.x ) else: - aux_values = None + aux_operators_evaluated = None - return self._build_vqe_result(optimizer_result, aux_values, eval_time) + return self._build_vqe_result(optimizer_result, aux_operators_evaluated, optimizer_time) @classmethod def supports_aux_operators(cls) -> bool: @@ -306,8 +306,8 @@ def _check_operator_ansatz(self, operator: BaseOperator | PauliSumOp): def _build_vqe_result( self, optimizer_result: OptimizerResult, - aux_values: ListOrDict[tuple[complex, tuple[complex, int]]], - eval_time: float, + aux_operators_evaluated: ListOrDict[tuple[complex, tuple[complex, int]]], + optimizer_time: float, ) -> VQEResult: result = VQEResult() result.eigenvalue = optimizer_result.fun @@ -315,8 +315,8 @@ def _build_vqe_result( result.optimal_point = optimizer_result.x result.optimal_parameters = dict(zip(self.ansatz.parameters, optimizer_result.x)) result.optimal_value = optimizer_result.fun - result.optimizer_time = eval_time - result.aux_operator_eigenvalues = aux_values + result.optimizer_time = optimizer_time + result.aux_operators_evaluated = aux_operators_evaluated result.optimizer_result = optimizer_result return result diff --git a/test/python/algorithms/minimum_eigensolvers/test_numpy_minimum_eigensolver.py b/test/python/algorithms/minimum_eigensolvers/test_numpy_minimum_eigensolver.py index 3201712ff0b6..8d2212e1d7b3 100644 --- a/test/python/algorithms/minimum_eigensolvers/test_numpy_minimum_eigensolver.py +++ b/test/python/algorithms/minimum_eigensolvers/test_numpy_minimum_eigensolver.py @@ -50,9 +50,9 @@ def test_cme(self): operator=self.qubit_op, aux_operators=self.aux_ops_list ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[0], [2, 0]) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[1], [0, 0]) + self.assertEqual(len(result.aux_operators_evaluated), 2) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[0], [2, 0]) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[1], [0, 0]) def test_cme_reuse(self): """Test reuse""" @@ -62,38 +62,38 @@ def test_cme_reuse(self): result = algo.compute_minimum_eigenvalue(operator=self.qubit_op) self.assertEqual(result.eigenvalue.dtype, np.float64) self.assertAlmostEqual(result.eigenvalue, -1.85727503) - self.assertIsNone(result.aux_operator_eigenvalues) + self.assertIsNone(result.aux_operators_evaluated) with self.subTest("Test with added aux_operators"): result = algo.compute_minimum_eigenvalue( operator=self.qubit_op, aux_operators=self.aux_ops_list ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[0], [2, 0]) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[1], [0, 0]) + self.assertEqual(len(result.aux_operators_evaluated), 2) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[0], [2, 0]) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[1], [0, 0]) with self.subTest("Test with aux_operators removed"): result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=[]) self.assertEqual(result.eigenvalue.dtype, np.float64) self.assertAlmostEqual(result.eigenvalue, -1.85727503) - self.assertIsNone(result.aux_operator_eigenvalues) + self.assertIsNone(result.aux_operators_evaluated) with self.subTest("Test with aux_operators set again"): result = algo.compute_minimum_eigenvalue( operator=self.qubit_op, aux_operators=self.aux_ops_list ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[0], [2, 0]) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[1], [0, 0]) + self.assertEqual(len(result.aux_operators_evaluated), 2) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[0], [2, 0]) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[1], [0, 0]) with self.subTest("Test after setting first aux_operators as main operator"): result = algo.compute_minimum_eigenvalue( operator=self.aux_ops_list[0], aux_operators=[] ) self.assertAlmostEqual(result.eigenvalue, 2 + 0j) - self.assertIsNone(result.aux_operator_eigenvalues) + self.assertIsNone(result.aux_operators_evaluated) def test_cme_filter(self): """Basic test""" @@ -108,9 +108,9 @@ def criterion(x, v, a_v): operator=self.qubit_op, aux_operators=self.aux_ops_list ) self.assertAlmostEqual(result.eigenvalue, -0.22491125 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[0], [2, 0]) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues[1], [0, 0]) + self.assertEqual(len(result.aux_operators_evaluated), 2) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[0], [2, 0]) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated[1], [0, 0]) def test_cme_filter_empty(self): """Test with filter always returning False""" @@ -126,7 +126,7 @@ def criterion(x, v, a_v): ) self.assertEqual(result.eigenvalue, None) self.assertEqual(result.eigenstate, None) - self.assertEqual(result.aux_operator_eigenvalues, None) + self.assertEqual(result.aux_operators_evaluated, None) @data("X", "Y", "Z") def test_cme_1q(self, op): @@ -144,16 +144,16 @@ def test_cme_aux_ops_dict(self): with self.subTest("Test with an empty dictionary."): result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators={}) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertIsNone(result.aux_operator_eigenvalues) + self.assertIsNone(result.aux_operators_evaluated) with self.subTest("Test with two auxiliary operators."): result = algo.compute_minimum_eigenvalue( operator=self.qubit_op, aux_operators=self.aux_ops_dict ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues["aux_op1"], [2, 0]) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues["aux_op2"], [0, 0]) + self.assertEqual(len(result.aux_operators_evaluated), 2) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated["aux_op1"], [2, 0]) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated["aux_op2"], [0, 0]) with self.subTest("Test with additional zero and None operators."): extra_ops = {"None_op": None, "zero_op": 0, **self.aux_ops_dict} @@ -161,10 +161,10 @@ def test_cme_aux_ops_dict(self): operator=self.qubit_op, aux_operators=extra_ops ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 3) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues["aux_op1"], [2, 0]) - np.testing.assert_array_almost_equal(result.aux_operator_eigenvalues["aux_op2"], [0, 0]) - self.assertEqual(result.aux_operator_eigenvalues["zero_op"], (0.0, 0)) + self.assertEqual(len(result.aux_operators_evaluated), 3) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated["aux_op1"], [2, 0]) + np.testing.assert_array_almost_equal(result.aux_operators_evaluated["aux_op2"], [0, 0]) + self.assertEqual(result.aux_operators_evaluated["zero_op"], (0.0, 0)) def test_aux_operators_list(self): """Test list-based aux_operators.""" @@ -176,13 +176,13 @@ def test_aux_operators_list(self): with self.subTest("Test with two auxiliary operators."): result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=aux_ops) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) + self.assertEqual(len(result.aux_operators_evaluated), 2) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues[0][0], 2, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues[1][0], 0, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[0][0], 2, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[1][0], 0, places=6) # standard deviations - self.assertAlmostEqual(result.aux_operator_eigenvalues[0][1], 0.0) - self.assertAlmostEqual(result.aux_operator_eigenvalues[1][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated[0][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated[1][1], 0.0) with self.subTest("Test with additional zero and None operators."): extra_ops = [*aux_ops, None, 0] @@ -190,16 +190,16 @@ def test_aux_operators_list(self): operator=self.qubit_op, aux_operators=extra_ops ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 4) + self.assertEqual(len(result.aux_operators_evaluated), 4) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues[0][0], 2, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues[1][0], 0, places=6) - self.assertIsNone(result.aux_operator_eigenvalues[2], None) - self.assertEqual(result.aux_operator_eigenvalues[3][0], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated[0][0], 2, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[1][0], 0, places=6) + self.assertIsNone(result.aux_operators_evaluated[2], None) + self.assertEqual(result.aux_operators_evaluated[3][0], 0.0) # standard deviations - self.assertAlmostEqual(result.aux_operator_eigenvalues[0][1], 0.0) - self.assertAlmostEqual(result.aux_operator_eigenvalues[1][1], 0.0) - self.assertEqual(result.aux_operator_eigenvalues[3][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated[0][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated[1][1], 0.0) + self.assertEqual(result.aux_operators_evaluated[3][1], 0.0) def test_aux_operators_dict(self): """Test dict-based aux_operators.""" @@ -211,13 +211,13 @@ def test_aux_operators_dict(self): with self.subTest("Test with two auxiliary operators."): result = algo.compute_minimum_eigenvalue(operator=self.qubit_op, aux_operators=aux_ops) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) + self.assertEqual(len(result.aux_operators_evaluated), 2) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][0], 2, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][0], 0, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op1"][0], 2, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op2"][0], 0, places=6) # standard deviations - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][1], 0.0) - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op1"][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op2"][1], 0.0) with self.subTest("Test with additional zero and None operators."): extra_ops = {**aux_ops, "None_operator": None, "zero_operator": 0} @@ -225,16 +225,16 @@ def test_aux_operators_dict(self): operator=self.qubit_op, aux_operators=extra_ops ) self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j) - self.assertEqual(len(result.aux_operator_eigenvalues), 3) + self.assertEqual(len(result.aux_operators_evaluated), 3) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][0], 2, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][0], 0, places=6) - self.assertEqual(result.aux_operator_eigenvalues["zero_operator"][0], 0.0) - self.assertTrue("None_operator" not in result.aux_operator_eigenvalues.keys()) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op1"][0], 2, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op2"][0], 0, places=6) + self.assertEqual(result.aux_operators_evaluated["zero_operator"][0], 0.0) + self.assertTrue("None_operator" not in result.aux_operators_evaluated.keys()) # standard deviations - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][1], 0.0) - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][1], 0.0) - self.assertAlmostEqual(result.aux_operator_eigenvalues["zero_operator"][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op1"][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op2"][1], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated["zero_operator"][1], 0.0) if __name__ == "__main__": diff --git a/test/python/algorithms/minimum_eigensolvers/test_vqe.py b/test/python/algorithms/minimum_eigensolvers/test_vqe.py index 171b52b9bcca..1ecc870237ec 100644 --- a/test/python/algorithms/minimum_eigensolvers/test_vqe.py +++ b/test/python/algorithms/minimum_eigensolvers/test_vqe.py @@ -369,8 +369,8 @@ def test_aux_operators_list(self): with self.subTest("Test with an empty list."): result = vqe.compute_minimum_eigenvalue(self.h2_op, aux_operators=[]) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6) - self.assertIsInstance(result.aux_operator_eigenvalues, list) - self.assertEqual(len(result.aux_operator_eigenvalues), 0) + self.assertIsInstance(result.aux_operators_evaluated, list) + self.assertEqual(len(result.aux_operators_evaluated), 0) with self.subTest("Test with two auxiliary operators."): aux_op1 = PauliSumOp.from_list([("II", 2.0)]) @@ -378,27 +378,27 @@ def test_aux_operators_list(self): aux_ops = [aux_op1, aux_op2] result = vqe.compute_minimum_eigenvalue(self.h2_op, aux_operators=aux_ops) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=5) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) + self.assertEqual(len(result.aux_operators_evaluated), 2) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues[0][0], 2.0, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues[1][0], 0.0, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[0][0], 2.0, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[1][0], 0.0, places=6) # metadata - self.assertIsInstance(result.aux_operator_eigenvalues[0][1], dict) - self.assertIsInstance(result.aux_operator_eigenvalues[1][1], dict) + self.assertIsInstance(result.aux_operators_evaluated[0][1], dict) + self.assertIsInstance(result.aux_operators_evaluated[1][1], dict) with self.subTest("Test with additional zero operator."): extra_ops = [*aux_ops, 0] result = vqe.compute_minimum_eigenvalue(self.h2_op, aux_operators=extra_ops) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=5) - self.assertEqual(len(result.aux_operator_eigenvalues), 3) + self.assertEqual(len(result.aux_operators_evaluated), 3) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues[0][0], 2.0, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues[1][0], 0.0, places=6) - self.assertAlmostEqual(result.aux_operator_eigenvalues[2][0], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated[0][0], 2.0, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[1][0], 0.0, places=6) + self.assertAlmostEqual(result.aux_operators_evaluated[2][0], 0.0) # metadata - self.assertIsInstance(result.aux_operator_eigenvalues[0][1], dict) - self.assertIsInstance(result.aux_operator_eigenvalues[1][1], dict) - self.assertIsInstance(result.aux_operator_eigenvalues[2][1], dict) + self.assertIsInstance(result.aux_operators_evaluated[0][1], dict) + self.assertIsInstance(result.aux_operators_evaluated[1][1], dict) + self.assertIsInstance(result.aux_operators_evaluated[2][1], dict) def test_aux_operators_dict(self): """Test dictionary compatibility of aux_operators""" @@ -407,8 +407,8 @@ def test_aux_operators_dict(self): with self.subTest("Test with an empty dictionary."): result = vqe.compute_minimum_eigenvalue(self.h2_op, aux_operators={}) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6) - self.assertIsInstance(result.aux_operator_eigenvalues, dict) - self.assertEqual(len(result.aux_operator_eigenvalues), 0) + self.assertIsInstance(result.aux_operators_evaluated, dict) + self.assertEqual(len(result.aux_operators_evaluated), 0) with self.subTest("Test with two auxiliary operators."): aux_op1 = PauliSumOp.from_list([("II", 2.0)]) @@ -416,28 +416,28 @@ def test_aux_operators_dict(self): aux_ops = {"aux_op1": aux_op1, "aux_op2": aux_op2} result = vqe.compute_minimum_eigenvalue(self.h2_op, aux_operators=aux_ops) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6) - self.assertEqual(len(result.aux_operator_eigenvalues), 2) + self.assertEqual(len(result.aux_operators_evaluated), 2) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][0], 2.0, places=5) - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][0], 0.0, places=5) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op1"][0], 2.0, places=5) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op2"][0], 0.0, places=5) # metadata - self.assertIsInstance(result.aux_operator_eigenvalues["aux_op1"][1], dict) - self.assertIsInstance(result.aux_operator_eigenvalues["aux_op2"][1], dict) + self.assertIsInstance(result.aux_operators_evaluated["aux_op1"][1], dict) + self.assertIsInstance(result.aux_operators_evaluated["aux_op2"][1], dict) with self.subTest("Test with additional zero operator."): extra_ops = {**aux_ops, "zero_operator": 0} result = vqe.compute_minimum_eigenvalue(self.h2_op, aux_operators=extra_ops) self.assertAlmostEqual(result.eigenvalue.real, self.h2_energy, places=6) - self.assertEqual(len(result.aux_operator_eigenvalues), 3) + self.assertEqual(len(result.aux_operators_evaluated), 3) # expectation values - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op1"][0], 2.0, places=5) - self.assertAlmostEqual(result.aux_operator_eigenvalues["aux_op2"][0], 0.0, places=5) - self.assertAlmostEqual(result.aux_operator_eigenvalues["zero_operator"][0], 0.0) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op1"][0], 2.0, places=5) + self.assertAlmostEqual(result.aux_operators_evaluated["aux_op2"][0], 0.0, places=5) + self.assertAlmostEqual(result.aux_operators_evaluated["zero_operator"][0], 0.0) # metadata - self.assertIsInstance(result.aux_operator_eigenvalues["aux_op1"][1], dict) - self.assertIsInstance(result.aux_operator_eigenvalues["aux_op2"][1], dict) - self.assertIsInstance(result.aux_operator_eigenvalues["zero_operator"][1], dict) + self.assertIsInstance(result.aux_operators_evaluated["aux_op1"][1], dict) + self.assertIsInstance(result.aux_operators_evaluated["aux_op2"][1], dict) + self.assertIsInstance(result.aux_operators_evaluated["zero_operator"][1], dict) if __name__ == "__main__":