def setUp(self):
super().setUp()
self.driver1 = HDF5Driver(hdf5_input=self.get_resource_path(
'test_oovqe_h4.hdf5', 'algorithms/ground_state_solvers'))
self.driver2 = HDF5Driver(hdf5_input=self.get_resource_path(
'test_oovqe_lih.hdf5', 'algorithms/ground_state_solvers'))
self.driver3 = HDF5Driver(hdf5_input=self.get_resource_path(
'test_oovqe_h4_uhf.hdf5', 'algorithms/ground_state_solvers'))
self.energy1_rotation = -3.0104
self.energy1 = -2.77 # energy of the VQE with pUCCD ansatz and LBFGSB optimizer
self.energy2 = -7.70
self.energy3 = -2.50
self.initial_point1 = [
0.039374, -0.47225463, -0.61891996, 0.02598386, 0.79045546,
-0.04134567, 0.04944946, -0.02971617, -0.00374005, 0.77542149
]
self.seed = 50
self.optimizer = COBYLA(maxiter=1)
self.transformation1 = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False)
self.transformation2 = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True)
self.quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=self.seed,
seed_transpiler=self.seed)
def test_freeze_core_with_remove_orbitals(self):
"""Test the `freeze_core` convenience argument in combination with `remove_orbitals`."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = FreezeCoreTransformer(freeze_core=True, remove_orbitals=[4, 5])
q_molecule_reduced = trafo.transform(q_molecule)
expected = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g_reduced.hdf5',
'transformers')).run()
self.assertQMolecule(q_molecule_reduced, expected, dict_key='FreezeCoreTransformer')
def test_freeze_core(self):
"""Test the `freeze_core` convenience argument."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('LiH_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = FreezeCoreTransformer(freeze_core=True)
q_molecule_reduced = trafo.transform(q_molecule)
expected = HDF5Driver(hdf5_input=self.get_resource_path('LiH_sto3g_reduced.hdf5',
'transformers')).run()
self.assertQMolecule(q_molecule_reduced, expected, dict_key='FreezeCoreTransformer')
def setUp(self):
super().setUp()
driver = HDF5Driver(hdf5_input=self.get_resource_path(
"test_driver_hdf5.hdf5", "drivers/second_quantization/hdf5d"))
temp_qmolecule = driver.run()
file, self.save_file = tempfile.mkstemp(suffix=".hdf5")
os.close(file)
temp_qmolecule.save(self.save_file)
# Tests are run on self.qmolecule which is from new saved HDF5 file
# so save is tested based on getting expected values as per original
driver = HDF5Driver(hdf5_input=self.save_file)
self.qmolecule = driver.run()
def test_unpaired_electron_active_space(self):
"""Test an active space with an unpaired electron."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=(2, 1), num_molecular_orbitals=3)
q_molecule_reduced = trafo.transform(q_molecule)
expected = HDF5Driver(hdf5_input=self.get_resource_path('BeH_sto3g_reduced.hdf5',
'transformers')).run()
self.assertQMolecule(q_molecule_reduced, expected)
def setUp(self):
super().setUp()
driver = HDF5Driver(hdf5_input=self.get_resource_path(
"test_driver_hdf5.hdf5", "drivers/hdf5d"))
self.molecule = driver.run()
self.num_particles = (self.molecule.num_alpha, self.molecule.num_beta)
self.h2_op = fermionic_op_builder._build_fermionic_op(self.molecule)
def test_minimal_active_space(self):
"""Test a minimal active space manually."""
driver = HDF5Driver(hdf5_input=self.get_resource_path(
"H2_631g.hdf5", "transformers/second_quantization/electronic"))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=2,
num_molecular_orbitals=2)
q_molecule_reduced = trafo.transform(q_molecule)
expected = QMolecule()
expected.mo_onee_ints = np.asarray([[-1.24943841, 0.0],
[0.0, -0.547816138]])
expected.mo_eri_ints = np.asarray([
[
[[0.652098466, 0.0], [0.0, 0.433536565]],
[[0.0, 0.0794483182], [0.0794483182, 0.0]],
],
[
[[0.0, 0.0794483182], [0.0794483182, 0.0]],
[[0.433536565, 0.0], [0.0, 0.385524695]],
],
])
expected.x_dip_mo_ints = np.zeros((2, 2))
expected.y_dip_mo_ints = np.zeros((2, 2))
expected.z_dip_mo_ints = np.asarray([[0.69447435, -1.01418298],
[-1.01418298, 0.69447435]])
expected.energy_shift["ActiveSpaceTransformer"] = 0.0
expected.x_dip_energy_shift["ActiveSpaceTransformer"] = 0.0
expected.y_dip_energy_shift["ActiveSpaceTransformer"] = 0.0
expected.z_dip_energy_shift["ActiveSpaceTransformer"] = 0.0
self.assertQMolecule(q_molecule_reduced, expected)
def test_excitation_preserving(self):
"""Test the excitation preserving wavefunction on a chemistry example."""
driver = HDF5Driver(
self.get_resource_path('test_driver_hdf5.hdf5', 'drivers/hdf5d'))
fermionic_transformation = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.PARITY,
two_qubit_reduction=False)
qubit_op, _ = fermionic_transformation.transform(driver)
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
fermionic_transformation.molecule_info['num_orbitals'],
fermionic_transformation.molecule_info['num_particles'],
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction)
wavefunction = ExcitationPreserving(qubit_op.num_qubits)
wavefunction.compose(initial_state, front=True, inplace=True)
solver = VQE(var_form=wavefunction,
optimizer=optimizer,
quantum_instance=QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
gsc = GroundStateEigensolver(fermionic_transformation, solver)
result = gsc.solve(driver)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy,
places=4)
def test_freeze_core(self):
"""Test the `freeze_core` convenience argument."""
driver = HDF5Driver(hdf5_input=self.get_resource_path(
"LiH_sto3g.hdf5", "transformers/second_quantization/electronic"))
q_molecule = driver.run()
trafo = FreezeCoreTransformer(freeze_core=True)
q_molecule_reduced = trafo.transform(q_molecule)
expected = HDF5Driver(hdf5_input=self.get_resource_path(
"LiH_sto3g_reduced.hdf5",
"transformers/second_quantization/electronic")).run()
self.assertQMolecule(q_molecule_reduced,
expected,
dict_key="FreezeCoreTransformer")
def test_second_q_ops_without_transformers(self):
"""Tests that the list of second quantized operators is created if no transformers
provided."""
expected_num_of_sec_quant_ops = 7
expected_fermionic_op_path = self.get_resource_path(
"H2_631g_ferm_op_two_ints",
"problems/second_quantization/electronic/resources",
)
expected_fermionic_op = read_expected_file(expected_fermionic_op_path)
driver = HDF5Driver(hdf5_input=self.get_resource_path("H2_631g.hdf5", "transformers"))
electronic_structure_problem = ElectronicStructureProblem(driver)
second_quantized_ops = electronic_structure_problem.second_q_ops()
electr_sec_quant_op = second_quantized_ops[0]
with self.subTest("Check expected length of the list of second quantized operators."):
assert len(second_quantized_ops) == expected_num_of_sec_quant_ops
with self.subTest("Check types in the list of second quantized operators."):
for second_quantized_op in second_quantized_ops:
assert isinstance(second_quantized_op, SecondQuantizedOp)
with self.subTest("Check components of electronic second quantized operator."):
assert all(
s[0] == t[0] and np.isclose(s[1], t[1])
for s, t in zip(expected_fermionic_op, electr_sec_quant_op.to_list())
)
def test_minimal_active_space(self):
"""Test a minimal active space manually."""
driver = HDF5Driver(
hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2)
q_molecule_reduced = trafo.transform(q_molecule)
expected_mo_onee_ints = np.asarray([[-1.24943841, 0.0],
[0.0, -0.547816138]])
expected_mo_eri_ints = np.asarray([[[[0.652098466, 0.0],
[0.0, 0.433536565]],
[[0.0, 0.0794483182],
[0.0794483182, 0.0]]],
[[[0.0, 0.0794483182],
[0.0794483182, 0.0]],
[[0.433536565, 0.0],
[0.0, 0.385524695]]]])
assert np.allclose(q_molecule_reduced.mo_onee_ints,
expected_mo_onee_ints)
assert np.allclose(q_molecule_reduced.mo_eri_ints,
expected_mo_eri_ints)
assert np.isclose(
q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_arbitrary_active_orbitals(self):
"""Test manual selection of active orbital indices."""
driver = HDF5Driver(
hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=2,
num_orbitals=2,
active_orbitals=[0, 2])
q_molecule_reduced = trafo.transform(q_molecule)
expected_mo_onee_ints = np.asarray([[-1.24943841, -0.16790838],
[-0.16790838, -0.18307469]])
expected_mo_eri_ints = np.asarray([[[[0.65209847, 0.16790822],
[0.16790822, 0.53250905]],
[[0.16790822, 0.10962908],
[0.10962908, 0.11981429]]],
[[[0.16790822, 0.10962908],
[0.10962908, 0.11981429]],
[[0.53250905, 0.11981429],
[0.11981429, 0.46345617]]]])
assert np.allclose(q_molecule_reduced.mo_onee_ints,
expected_mo_onee_ints)
assert np.allclose(q_molecule_reduced.mo_eri_ints,
expected_mo_eri_ints)
assert np.isclose(
q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_second_q_ops_with_active_space(self):
"""Tests that the correct second quantized operator is created if an active space
transformer is provided."""
expected_num_of_sec_quant_ops = 7
expected_fermionic_op_path = self.get_resource_path(
'H2_631g_ferm_op_active_space', 'problems/second_quantization/'
'electronic/resources')
expected_fermionic_op = read_expected_file(expected_fermionic_op_path)
driver = HDF5Driver(
hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers'))
trafo = ActiveSpaceTransformer(num_electrons=2,
num_molecular_orbitals=2)
electronic_structure_problem = ElectronicStructureProblem(
driver, [trafo])
second_quantized_ops = electronic_structure_problem.second_q_ops()
electr_sec_quant_op = second_quantized_ops[0]
with self.subTest(
"Check expected length of the list of second quantized operators."
):
assert len(second_quantized_ops) == expected_num_of_sec_quant_ops
with self.subTest(
"Check types in the list of second quantized operators."):
for second_quantized_op in second_quantized_ops:
assert isinstance(second_quantized_op, SecondQuantizedOp)
with self.subTest(
"Check components of electronic second quantized operator."):
assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip(
expected_fermionic_op, electr_sec_quant_op.to_list()))
def setUp(self):
super().setUp()
self.skipTest("Skip test until refactored.")
self.reference_energy = -1.1373060356951838
self.seed = 700
algorithm_globals.random_seed = self.seed
self.driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5',
'drivers/hdf5d'))
fermionic_transformation = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.PARITY,
two_qubit_reduction=False)
self.qubit_op, _ = fermionic_transformation.transform(self.driver)
self.fermionic_transformation = fermionic_transformation
self.optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
fermionic_transformation.molecule_info['num_orbitals'],
fermionic_transformation.molecule_info['num_particles'],
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction)
self.var_form = UCCSD(
num_orbitals=fermionic_transformation.molecule_info['num_orbitals'],
num_particles=fermionic_transformation.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction)
def test_second_q_ops_without_transformers(self):
"""Tests that the list of second quantized operators is created if no transformers
provided."""
expected_num_of_sec_quant_ops = 7
expected_fermionic_op_path = self.get_resource_path(
'H2_631g_ferm_op_two_ints', 'problems/second_quantization/'
'molecular/resources')
expected_fermionic_op = read_expected_file(expected_fermionic_op_path)
driver = HDF5Driver(
hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers'))
molecular_problem = MolecularProblem(driver)
second_quantized_ops = molecular_problem.second_q_ops()
electr_sec_quant_op = second_quantized_ops[0]
with self.subTest(
"Check expected length of the list of second quantized operators."
):
assert len(second_quantized_ops) == expected_num_of_sec_quant_ops
with self.subTest(
"Check types in the list of second quantized operators."):
for second_quantized_op in second_quantized_ops:
assert isinstance(second_quantized_op, SecondQuantizedOp)
with self.subTest(
"Check components of electronic second quantized operator."):
assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in zip(
expected_fermionic_op, electr_sec_quant_op.fermion.to_list()))
assert electr_sec_quant_op.boson is None
assert electr_sec_quant_op.spin == {}
def test_error_raising(self, num_electrons, num_molecular_orbitals, active_orbitals, message):
"""Test errors are being raised in certain scenarios."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
with self.assertRaises(QiskitNatureError, msg=message):
ActiveSpaceTransformer(num_electrons=num_electrons,
num_molecular_orbitals=num_molecular_orbitals,
active_orbitals=active_orbitals).transform(q_molecule)
def setUp(self):
super().setUp()
driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5',
'drivers/hdf5d'))
fermionic_transformation = \
FermionicTransformation(transformation=FermionicTransformationType.FULL,
qubit_mapping=FermionicQubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=False,
orbital_reduction=[])
self.qubit_op, self.aux_ops = fermionic_transformation.transform(driver)
self.reference_energy = -1.857275027031588
def test_molecular_problem_sector_locator_z2_symmetry(self):
""" Test mapping to qubit operator with z2 symmetry tapering and two qubit reduction """
driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5',
'drivers/hdf5d'))
problem = ElectronicStructureProblem(driver)
mapper = JordanWignerMapper()
qubit_conv = QubitConverter(mapper, two_qubit_reduction=True, z2symmetry_reduction='auto')
qubit_op = qubit_conv.convert(problem.second_q_ops()[0], self.num_particles,
sector_locator=problem.symmetry_sector_locator)
self.assertEqual(qubit_op, TestQubitConverter.REF_H2_JW_TAPERED)
def test_full_active_space(self, kwargs):
"""Test that transformer has no effect when all orbitals are active."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
q_molecule.energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.x_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.y_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.z_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
trafo = ActiveSpaceTransformer(**kwargs)
q_molecule_reduced = trafo.transform(q_molecule)
self.assertQMolecule(q_molecule_reduced, q_molecule)
def setUp(self):
super().setUp()
self.driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5',
'drivers/hdf5d'))
self.seed = 56
algorithm_globals.random_seed = self.seed
self.reference_energy = -1.1373060356951838
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(self.driver)
self.num_spin_orbitals = 4
self.num_particles = (1, 1)
def test_active_space_for_q_molecule_v2(self):
"""Test based on QMolecule v2 (mo_occ not available)."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g_v2.hdf5', 'transformers'))
q_molecule = driver.run()
q_molecule.energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.x_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.y_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.z_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
trafo = ActiveSpaceTransformer(num_electrons=2, num_molecular_orbitals=2)
q_molecule_reduced = trafo.transform(q_molecule)
self.assertQMolecule(q_molecule_reduced, q_molecule)
def test_unpaired_electron_active_space(self):
"""Test an active space with an unpaired electron."""
driver = HDF5Driver(hdf5_input=self.get_resource_path(
'BeH_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=3,
num_orbitals=3,
num_alpha=2)
q_molecule_reduced = trafo.transform(q_molecule)
expected_mo_onee_ints = np.asarray([[-1.30228816, 0.03573328, 0.0],
[0.03573328, -0.86652349, 0.0],
[0.0, 0.0, -0.84868407]])
expected_mo_eri_ints = np.asarray([[[[0.57237421, -0.05593597, 0.0],
[-0.05593597, 0.30428426, 0.0],
[0.0, 0.0, 0.36650821]],
[[-0.05593597, 0.01937529, 0.0],
[0.01937529, 0.02020237, 0.0],
[0.0, 0.0, 0.01405676]],
[[0.0, 0.0, 0.03600701],
[0.0, 0.0, 0.028244],
[0.03600701, 0.028244, 0.0]]],
[[[-0.05593597, 0.01937529, 0.0],
[0.01937529, 0.02020237, 0.0],
[0.0, 0.0, 0.01405676]],
[[0.30428426, 0.02020237, 0.0],
[0.02020237, 0.48162669, 0.0],
[0.0, 0.0, 0.40269913]],
[[0.0, 0.0, 0.028244],
[0.0, 0.0, 0.0564951],
[0.028244, 0.0564951, 0.0]]],
[[[0.0, 0.0, 0.03600701],
[0.0, 0.0, 0.028244],
[0.03600701, 0.028244, 0.0]],
[[0.0, 0.0, 0.028244],
[0.0, 0.0, 0.0564951],
[0.028244, 0.0564951, 0.0]],
[[0.36650821, 0.01405676, 0.0],
[0.01405676, 0.40269913, 0.0],
[0.0, 0.0, 0.44985904]]]])
assert np.allclose(q_molecule_reduced.mo_onee_ints,
expected_mo_onee_ints)
assert np.allclose(q_molecule_reduced.mo_eri_ints,
expected_mo_eri_ints)
assert np.isclose(
q_molecule_reduced.energy_shift['ActiveSpaceTransformer'],
-14.2538029231)
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 42
driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5',
'drivers/hdf5d'))
problem = ElectronicStructureProblem(driver)
second_q_ops = problem.second_q_ops()
converter = QubitConverter(mapper=ParityMapper(), two_qubit_reduction=True)
num_particles = (problem.molecule_data_transformed.num_alpha,
problem.molecule_data_transformed.num_beta)
self.qubit_op = converter.convert(second_q_ops[0], num_particles)
self.aux_ops = converter.convert_match(second_q_ops[1:])
self.reference_energy = -1.857275027031588
def test_mapping(self):
""" Test mapping to qubit operator """
driver = HDF5Driver(hdf5_input=self.get_resource_path('test_driver_hdf5.hdf5',
'drivers/hdf5d'))
q_molecule = driver.run()
fermionic_op = fermionic_op_builder._build_fermionic_op(q_molecule)
mapper = JordanWignerMapper()
qubit_op = mapper.map(fermionic_op)
# Note: The PauliSumOp equals, as used in the test below, use the equals of the
# SparsePauliOp which in turn uses np.allclose() to determine equality of
# coeffs. So the reference operator above will be matched on that basis so
# we don't need to worry about tiny precision changes for any reason.
self.assertEqual(qubit_op, TestJordanWignerMapper.REF_H2)
def test_active_space_for_q_molecule_v2(self):
"""Test based on QMolecule v2 (mo_occ not available)."""
driver = HDF5Driver(hdf5_input=self.get_resource_path(
'H2_sto3g_v2.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2)
q_molecule_reduced = trafo.transform(q_molecule)
assert np.allclose(q_molecule_reduced.mo_onee_ints,
q_molecule.mo_onee_ints)
assert np.allclose(q_molecule_reduced.mo_eri_ints,
q_molecule.mo_eri_ints)
assert np.isclose(
q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_full_active_space(self):
"""Test that transformer has no effect when all orbitals are active."""
driver = HDF5Driver(
hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
trafo = ActiveSpaceTransformer(num_electrons=2, num_orbitals=2)
q_molecule_reduced = trafo.transform(q_molecule)
assert np.allclose(q_molecule_reduced.mo_onee_ints,
q_molecule.mo_onee_ints)
assert np.allclose(q_molecule_reduced.mo_eri_ints,
q_molecule.mo_eri_ints)
assert np.isclose(
q_molecule_reduced.energy_shift['ActiveSpaceTransformer'], 0.0)
def test_full_active_space(self, kwargs):
"""Test that transformer has no effect when all orbitals are active."""
driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_sto3g.hdf5', 'transformers'))
q_molecule = driver.run()
# The references which we compare too were produced by the `ActiveSpaceTransformer` and,
# thus, the key here needs to stay the same as in that test case.
q_molecule.energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.x_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.y_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
q_molecule.z_dip_energy_shift['ActiveSpaceTransformer'] = 0.0
trafo = FreezeCoreTransformer(**kwargs)
q_molecule_reduced = trafo.transform(q_molecule)
self.assertQMolecule(q_molecule_reduced, q_molecule, dict_key='FreezeCoreTransformer')
def test_build_fermionic_op(self):
"""Tests that the correct FermionicOp is built from QMolecule."""
expected_num_of_terms_ferm_op = 184
expected_fermionic_op_path = self.get_resource_path('H2_631g_ferm_op_two_ints',
'problems/second_quantization/'
'molecular/resources')
expected_fermionic_op = read_expected_file(expected_fermionic_op_path)
driver = HDF5Driver(hdf5_input=self.get_resource_path('H2_631g.hdf5', 'transformers'))
q_molecule = driver.run()
fermionic_op = fermionic_op_builder.build_fermionic_op(q_molecule)
with self.subTest("Check type of fermionic operator"):
assert isinstance(fermionic_op, FermionicOp)
with self.subTest("Check expected number of terms in a fermionic operator."):
assert len(fermionic_op) == expected_num_of_terms_ferm_op
with self.subTest("Check expected content of a fermionic operator."):
assert all(s[0] == t[0] and np.isclose(s[1], t[1]) for s, t in
zip(fermionic_op.to_list(), expected_fermionic_op))
def test_excitation_preserving(self):
"""Test the excitation preserving wavefunction on a chemistry example."""
driver = HDF5Driver(
self.get_resource_path("test_driver_hdf5.hdf5", "drivers/hdf5d"))
converter = QubitConverter(ParityMapper())
problem = ElectronicStructureProblem(driver)
_ = problem.second_q_ops()
num_particles = (
problem.molecule_data_transformed.num_alpha,
problem.molecule_data_transformed.num_beta,
)
num_spin_orbitals = problem.molecule_data_transformed.num_molecular_orbitals * 2
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(num_spin_orbitals, num_particles,
converter)
wavefunction = ExcitationPreserving(num_spin_orbitals)
wavefunction.compose(initial_state, front=True, inplace=True)
solver = VQE(
ansatz=wavefunction,
optimizer=optimizer,
quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
),
)
gsc = GroundStateEigensolver(converter, solver)
result = gsc.solve(problem)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy,
places=4)
def test_build_fermionic_op_from_ints_both(self):
"""Tests that the correct FermionicOp is built from 1- and 2-body integrals."""
expected_num_of_terms_ferm_op = 184
expected_fermionic_op_path = self.get_resource_path(
"H2_631g_ferm_op_two_ints",
"problems/second_quantization/electronic/resources",
)
expected_fermionic_op = read_expected_file(expected_fermionic_op_path)
driver = HDF5Driver(
hdf5_input=self.get_resource_path("H2_631g.hdf5", "transformers"))
q_molecule = driver.run()
fermionic_op = fermionic_op_builder.build_ferm_op_from_ints(
q_molecule.one_body_integrals, q_molecule.two_body_integrals)
with self.subTest("Check type of fermionic operator"):
assert isinstance(fermionic_op, FermionicOp)
with self.subTest(
"Check expected number of terms in a fermionic operator."):
assert len(fermionic_op) == expected_num_of_terms_ferm_op
with self.subTest("Check expected content of a fermionic operator."):
assert all(
s[0] == t[0] and np.isclose(s[1], t[1])
for s, t in zip(fermionic_op.to_list(), expected_fermionic_op))
