def test_reuse(self):
"""Test re-using a VQE algorithm instance."""
vqe = VQE()
with self.subTest(msg="assert running empty raises AlgorithmError"):
with self.assertRaises(AlgorithmError):
_ = vqe.compute_minimum_eigenvalue(operator=self.h2_op)
ansatz = TwoLocal(rotation_blocks=["ry", "rz"],
entanglement_blocks="cz")
vqe.ansatz = ansatz
with self.subTest(msg="assert missing operator raises AlgorithmError"):
with self.assertRaises(AlgorithmError):
_ = vqe.compute_minimum_eigenvalue(operator=self.h2_op)
vqe.expectation = MatrixExpectation()
vqe.quantum_instance = self.statevector_simulator
with self.subTest(msg="assert VQE works once all info is available"):
result = vqe.compute_minimum_eigenvalue(operator=self.h2_op)
self.assertAlmostEqual(result.eigenvalue.real,
self.h2_energy,
places=5)
operator = PrimitiveOp(
np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 2, 0], [0, 0, 0,
3]]))
with self.subTest(msg="assert minimum eigensolver interface works"):
result = vqe.compute_minimum_eigenvalue(operator=operator)
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
def _compute_gradients(
self,
theta: List[float],
vqe: VQE,
) -> List[Tuple[float, PauliSumOp]]:
"""
Computes the gradients for all available excitation operators.
Args:
theta: list of (up to now) optimal parameters
vqe: the variational quantum eigensolver instance used for solving
Returns:
List of pairs consisting of gradient and excitation operator.
"""
res = []
# compute gradients for all excitation in operator pool
for exc in self._excitation_pool:
# add next excitation to ansatz
self._ansatz.operators = self._excitation_list + [exc]
# set the current ansatz
vqe.ansatz = self._ansatz
ansatz_params = vqe.ansatz._parameter_table.keys()
# construct the expectation operator of the VQE
vqe._expect_op = vqe.construct_expectation(ansatz_params,
self._main_operator)
# evaluate energies
parameter_sets = theta + [-self._delta] + theta + [self._delta]
energy_results = vqe._energy_evaluation(np.asarray(parameter_sets))
# compute gradient
gradient = (energy_results[0] - energy_results[1]) / (2 *
self._delta)
res.append((np.abs(gradient), exc))
return res
def test_set_ansatz_to_none(self):
"""Tests that setting the ansatz to None results in the default behavior"""
vqe = VQE(
ansatz=self.ryrz_wavefunction,
optimizer=L_BFGS_B(),
quantum_instance=self.statevector_simulator,
)
vqe.ansatz = None
self.assertIsInstance(vqe.ansatz, RealAmplitudes)