def test_ee(self):
""" EE test """
dummy_operator = MatrixOperator([[1]])
ee = NumPyMinimumEigensolver()
output = ee.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503)
def setUp(self):
super().setUp()
try:
self.molecule = "H 0.000000 0.000000 0.735000;H 0.000000 0.000000 0.000000"
self.driver = PySCFDriver(atom=self.molecule,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='631g')
self.qmolecule = self.driver.run()
self.core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[])
self.qubit_op, _ = self.core.run(self.qmolecule)
z2_symmetries = Z2Symmetries.find_Z2_symmetries(self.qubit_op)
tapered_ops = z2_symmetries.taper(self.qubit_op)
smallest_eig_value = 99999999999999
smallest_idx = -1
for idx, _ in enumerate(tapered_ops):
ee = NumPyMinimumEigensolver(tapered_ops[idx])
curr_value = ee.compute_minimum_eigenvalue().eigenvalue.real
if curr_value < smallest_eig_value:
smallest_eig_value = curr_value
smallest_idx = idx
self.the_tapered_op = tapered_ops[smallest_idx]
self.reference_energy_pUCCD = -1.1434447924298028
self.reference_energy_UCCD0 = -1.1476045878481704
self.reference_energy_UCCD0full = -1.1515491334334347
# reference energy of UCCSD/VQE with tapering everywhere
self.reference_energy_UCCSD = -1.1516142309717594
# reference energy of UCCSD/VQE when no tapering on excitations is used
self.reference_energy_UCCSD_no_tap_exc = -1.1516142309717594
# excitations for succ
self.reference_singlet_double_excitations = [[0, 1, 4, 5],
[0, 1, 4, 6],
[0, 1, 4, 7],
[0, 2, 4, 6],
[0, 2, 4, 7],
[0, 3, 4, 7]]
# groups for succ_full
self.reference_singlet_groups = [[[0, 1, 4, 5]],
[[0, 1, 4, 6], [0, 2, 4, 5]],
[[0, 1, 4, 7], [0, 3, 4, 5]],
[[0, 2, 4, 6]],
[[0, 2, 4, 7], [0, 3, 4, 6]],
[[0, 3, 4, 7]]]
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
def test_no_symmetry(self):
""" No symmetry reduction """
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=None,
z2symmetry_reduction=None)
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 12)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(npme.compute_minimum_eigenvalue())
self._validate_result(result, False)
def test_given_symmetry(self):
""" Supplied symmetry reduction """
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=None,
z2symmetry_reduction=[1, 1, 1, 1])
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 8)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(npme.compute_minimum_eigenvalue())
self._validate_result(result)
self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1, 1, 1])
def test_auto_ph_freeze_core_parity_2(self):
""" Auto symmetry reduction, with freeze core, parity and two q reduction """
core = Hamiltonian(transformation=TransformationType.PARTICLE_HOLE,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=None,
z2symmetry_reduction='auto')
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 6)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(npme.compute_minimum_eigenvalue())
self._validate_result(result)
self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [1, 1])
def _run_driver(driver,
transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True):
qmolecule = driver.run()
core = Hamiltonian(transformation=transformation,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
freeze_core=freeze_core,
orbital_reduction=[])
qubit_op, aux_ops = core.run(qmolecule)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
result = core.process_algorithm_result(
npme.compute_minimum_eigenvalue())
return result
def test_cme_reuse(self):
""" Test reuse """
# Start with no operator or aux_operators, give via compute method
algo = NumPyMinimumEigensolver()
result = algo.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertEqual(self.qubit_op, algo.operator)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set operator to None and go again
algo.operator = None
with self.assertRaises(AquaError):
_ = algo.run()
# Set operator back as it was and go again
algo.operator = self.qubit_op
result = algo.compute_minimum_eigenvalue()
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
# Add aux_operators and go again
result = algo.compute_minimum_eigenvalue(aux_operators=self.aux_ops)
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])
# "Remove" aux_operators and go again
result = algo.compute_minimum_eigenvalue(aux_operators=[])
self.assertAlmostEqual(result.eigenvalue, -1.85727503 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
# Set aux_operators and go again
algo.aux_operators = self.aux_ops
result = algo.compute_minimum_eigenvalue()
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])
np.testing.assert_array_equal(self.aux_ops, algo.aux_operators)
# Finally just set one of aux_operators and main operator, remove aux_operators
result = algo.compute_minimum_eigenvalue(self.aux_ops[0], [])
self.assertAlmostEqual(result.eigenvalue, 2 + 0j)
self.assertIsNone(result.aux_operator_eigenvalues)
def test_auto_symmetry(self):
""" Auto symmetry reduction """
warnings.filterwarnings('ignore', category=DeprecationWarning)
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=None,
z2symmetry_reduction='auto')
warnings.filterwarnings('always', category=DeprecationWarning)
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 8)
npme = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops)
warnings.filterwarnings('ignore', category=DeprecationWarning)
result = core.process_algorithm_result(
npme.compute_minimum_eigenvalue())
warnings.filterwarnings('always', category=DeprecationWarning)
self._validate_result(result)
self.assertEqual(
core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values,
[1, 1, 1, 1])
