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 setUp(self):
super().setUp()
self.driver = PySCFDriver(atom='H 0 0 0.735; H 0 0 0', basis='631g')
self.qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
self.electronic_structure_problem = ElectronicStructureProblem(self.driver,
[FreezeCoreTransformer()])
self.num_spin_orbitals = 8
self.num_particles = (1, 1)
# because we create the initial state and ansatzes early, we need to ensure the qubit
# converter already ran such that convert_match works as expected
_ = self.qubit_converter.convert(self.electronic_structure_problem.second_q_ops()[0],
self.num_particles)
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]]]
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 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)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning)
driver = LegacyHDF5Driver(hdf5_input=self.get_resource_path(
"H2_631g.hdf5", "transformers/second_quantization/electronic"))
trafo = LegacyActiveSpaceTransformer(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 that the correct properties are/aren't None"):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning)
# legacy driver used, molecule_data should not be None
self.assertIsNotNone(
electronic_structure_problem.molecule_data)
# transformer used, molecule_data_transformed should not be None
self.assertIsNotNone(
electronic_structure_problem.molecule_data_transformed)
# converted properties should never be None
self.assertIsNotNone(electronic_structure_problem.grouped_property)
self.assertIsNotNone(
electronic_structure_problem.grouped_property_transformed)
with self.subTest(
"Check that the deprecated molecule_data property is not None"
):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning)
self.assertIsNotNone(
electronic_structure_problem.molecule_data)
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.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_h2_bopes_sampler(self):
"""Test BOPES Sampler on H2"""
# Molecule
dof = partial(Molecule.absolute_distance, atom_pair=(1, 0))
m = Molecule(
geometry=[["H", [0.0, 0.0, 1.0]], ["H", [0.0, 0.45, 1.0]]],
degrees_of_freedom=[dof],
)
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
driver = ElectronicStructureMoleculeDriver(
m, driver_type=ElectronicStructureDriverType.PYSCF)
problem = ElectronicStructureProblem(driver)
solver = NumPyMinimumEigensolver()
me_gss = GroundStateEigensolver(converter, solver)
# BOPES sampler
sampler = BOPESSampler(gss=me_gss)
# absolute internuclear distance in Angstrom
points = [0.7, 1.0, 1.3]
results = sampler.sample(problem, points)
points_run = results.points
energies = results.energies
np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3])
np.testing.assert_array_almost_equal(
energies, [-1.13618945, -1.10115033, -1.03518627], decimal=2)
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitNatureError:
self.skipTest('PYSCF driver does not appear to be installed')
self.reference_energies = [
-1.8427016, -1.8427016 + 0.5943372, -1.8427016 + 0.95788352,
-1.8427016 + 1.5969296
]
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
solver = NumPyEigensolver()
self.ref = solver
self.quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_transpiler=90,
seed_simulator=12)
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
self.driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.75",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.reference_energies = [
-1.8427016,
-1.8427016 + 0.5943372,
-1.8427016 + 0.95788352,
-1.8427016 + 1.5969296,
]
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
solver = NumPyEigensolver()
self.ref = solver
self.quantum_instance = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_transpiler=90,
seed_simulator=12,
)
def setUp(self):
super().setUp()
warnings.filterwarnings("ignore", category=DeprecationWarning, module=".*drivers.*")
self.driver = HDF5Driver(
self.get_resource_path("test_driver_hdf5.hdf5", "drivers/second_quantization/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_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 setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitNatureError:
self.skipTest('PYSCF driver does not appear to be installed')
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
self.electronic_structure_problem.second_q_ops()
self.q_molecule = self.electronic_structure_problem.molecule_data
def test_sector_locator_h2o(self):
"""Test sector locator."""
driver = PySCFDriver(
atom=
"O 0.0000 0.0000 0.1173; H 0.0000 0.07572 -0.4692;H 0.0000 -0.07572 -0.4692",
basis="sto-3g",
)
es_problem = ElectronicStructureProblem(driver)
qubit_conv = QubitConverter(mapper=ParityMapper(),
two_qubit_reduction=True,
z2symmetry_reduction="auto")
qubit_conv.convert(
es_problem.second_q_ops()[0],
num_particles=es_problem.num_particles,
sector_locator=es_problem.symmetry_sector_locator,
)
self.assertListEqual(qubit_conv.z2symmetries.tapering_values, [1, -1])
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
self.driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.75",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
self.electronic_structure_problem.second_q_ops()
self.particle_number = (
self.electronic_structure_problem.grouped_property_transformed.
get_property("ParticleNumber"))
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/second_quantization/electronic"))
electronic_structure_problem = ElectronicStructureProblem(driver)
second_quantized_ops = electronic_structure_problem.second_q_ops()
electr_sec_quant_op = second_quantized_ops[
electronic_structure_problem.main_property_name]
second_quantized_ops = list(second_quantized_ops.values())
with self.subTest("Check that the correct properties are/aren't None"):
with warnings.catch_warnings():
warnings.filterwarnings("ignore", category=DeprecationWarning)
# new driver used, molecule_data* should be None
self.assertIsNone(electronic_structure_problem.molecule_data)
self.assertIsNone(
electronic_structure_problem.molecule_data_transformed)
# converted properties should never be None
self.assertIsNotNone(electronic_structure_problem.grouped_property)
self.assertIsNotNone(
electronic_structure_problem.grouped_property_transformed)
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_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 setUp(self):
super().setUp()
self.driver = PySCFDriver(atom="H .0 .0 .0; H .0 .0 0.735",
unit=UnitsType.ANGSTROM,
basis="sto3g")
self.problem = ElectronicStructureProblem(self.driver)
self.expected = -1.85727503
self.qubit_converter = QubitConverter(ParityMapper())
def test_sector_locator_homonuclear(self):
"""Test sector locator."""
molecule = Molecule(geometry=[("Li", [0.0, 0.0, 0.0]),
("Li", [0.0, 0.0, 2.771])],
charge=0,
multiplicity=1)
freeze_core_transformer = FreezeCoreTransformer(True)
driver = ElectronicStructureMoleculeDriver(
molecule,
basis="sto3g",
driver_type=ElectronicStructureDriverType.PYSCF)
es_problem = ElectronicStructureProblem(
driver, transformers=[freeze_core_transformer])
qubit_conv = QubitConverter(mapper=ParityMapper(),
two_qubit_reduction=True,
z2symmetry_reduction="auto")
qubit_conv.convert(
es_problem.second_q_ops()[0],
num_particles=es_problem.num_particles,
sector_locator=es_problem.symmetry_sector_locator,
)
self.assertListEqual(qubit_conv.z2symmetries.tapering_values, [-1, 1])
def _run_driver(driver: FermionicDriver,
converter: QubitConverter = QubitConverter(
JordanWignerMapper()),
transformers: Optional[List[BaseTransformer]] = None):
problem = ElectronicStructureProblem(driver, transformers)
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(converter, solver)
result = gsc.solve(problem)
return result
def setUp(self):
super().setUp()
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
except QiskitNatureError:
self.skipTest('PYSCF driver does not appear to be installed')
return
self.problem = ElectronicStructureProblem(self.driver)
self.expected = -1.85727503
self.qubit_converter = QubitConverter(ParityMapper())
def test_h2_bopes_sampler_excited_eigensolver(self):
"""Test BOPES Sampler on H2"""
# Molecule
dof = partial(Molecule.absolute_distance, atom_pair=(1, 0))
m = Molecule(
geometry=[["H", [0.0, 0.0, 1.0]], ["H", [0.0, 0.45, 1.0]]],
degrees_of_freedom=[dof],
)
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper)
driver = ElectronicStructureMoleculeDriver(
m, driver_type=ElectronicStructureDriverType.PYSCF)
problem = ElectronicStructureProblem(driver)
# pylint: disable=unused-argument
def filter_criterion(eigenstate, eigenvalue, aux_values):
particle_number_filter = np.isclose(
aux_values["ParticleNumber"][0], 2.0)
magnetization_filter = np.isclose(aux_values["Magnetization"][0],
0.0)
return particle_number_filter and magnetization_filter
solver = NumPyEigensolverFactory(filter_criterion=filter_criterion)
np_excited_solver = ExcitedStatesEigensolver(converter, solver)
# BOPES sampler
sampler = BOPESSampler(np_excited_solver)
# absolute internuclear distance in Angstrom
points = [0.7, 1.0, 1.3]
results = sampler.sample(problem, points)
points_run = results.points
energies = results.energies
np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3])
np.testing.assert_array_almost_equal(
energies,
[
[-1.13618945, -0.47845306, -0.1204519, 0.5833141],
[-1.10115033, -0.74587179, -0.35229063, 0.03904763],
[-1.03518627, -0.85523694, -0.42240202, -0.21860355],
],
decimal=2,
)
def test_LiH(self):
"""Lih test"""
driver = PySCFDriver(
atom="Li .0 .0 .0; H .0 .0 1.6",
unit=UnitsType.ANGSTROM,
basis="sto3g",
)
transformer = ActiveSpaceTransformer(num_electrons=2,
num_molecular_orbitals=3)
problem = ElectronicStructureProblem(driver, [transformer])
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(problem)
self.assertAlmostEqual(res.electronic_energies[0],
-8.855126478,
places=6)
def test_h2_bopes_sampler_qeom(self):
"""Test BOPES Sampler on H2"""
# Molecule
dof = partial(Molecule.absolute_distance, atom_pair=(1, 0))
m = Molecule(
geometry=[["H", [0.0, 0.0, 1.0]], ["H", [0.0, 0.45, 1.0]]],
degrees_of_freedom=[dof],
)
driver = ElectronicStructureMoleculeDriver(
m, driver_type=ElectronicStructureDriverType.PYSCF)
problem = ElectronicStructureProblem(driver)
qubit_converter = QubitConverter(JordanWignerMapper(),
z2symmetry_reduction=None)
quantum_instance = QuantumInstance(
backend=qiskit.providers.aer.Aer.get_backend(
"aer_simulator_statevector"),
seed_simulator=self.seed,
seed_transpiler=self.seed,
)
solver = VQE(quantum_instance=quantum_instance)
me_gsc = GroundStateEigensolver(qubit_converter, solver)
qeom_solver = QEOM(me_gsc, "sd")
# BOPES sampler
sampler = BOPESSampler(qeom_solver)
# absolute internuclear distance in Angstrom
points = [0.7, 1.0, 1.3]
results = sampler.sample(problem, points)
points_run = results.points
energies = results.energies
np.testing.assert_array_almost_equal(points_run, [0.7, 1.0, 1.3])
np.testing.assert_array_almost_equal(
energies,
[
[-1.13618945, -0.47845306, -0.1204519, 0.5833141],
[-1.10115033, -0.74587179, -0.35229063, 0.03904763],
[-1.03518627, -0.85523694, -0.42240202, -0.21860355],
],
decimal=2,
)
def test_freeze_core_z2_symmetry_compatibility(self):
"""Regression test against #192.
An issue arose when the FreezeCoreTransformer was combined with the automatic Z2Symmetry
reduction. This regression test ensures that this behavior remains fixed.
"""
driver = HDF5Driver(hdf5_input=self.get_resource_path(
"LiH_sto3g.hdf5", "transformers/second_quantization/electronic"))
problem = ElectronicStructureProblem(driver, [FreezeCoreTransformer()])
qubit_converter = QubitConverter(
ParityMapper(),
two_qubit_reduction=True,
z2symmetry_reduction="auto",
)
solver = NumPyMinimumEigensolverFactory()
gsc = GroundStateEigensolver(qubit_converter, solver)
result = gsc.solve(problem)
self.assertAlmostEqual(result.total_energies[0], -7.882, places=2)
def test_potential_interface(self):
"""Tests potential interface."""
seed = 50
algorithm_globals.random_seed = seed
stretch = partial(Molecule.absolute_distance, atom_pair=(1, 0))
# H-H molecule near equilibrium geometry
m = Molecule(
geometry=[
["H", [0.0, 0.0, 0.0]],
["H", [1.0, 0.0, 0.0]],
],
degrees_of_freedom=[stretch],
masses=[1.6735328e-27, 1.6735328e-27],
)
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper)
driver = PySCFDriver(molecule=m)
problem = ElectronicStructureProblem(driver)
solver = NumPyMinimumEigensolver()
me_gss = GroundStateEigensolver(converter, solver)
# Run BOPESSampler with exact eigensolution
points = np.arange(0.45, 5.3, 0.3)
sampler = BOPESSampler(gss=me_gss)
res = sampler.sample(problem, points)
# Testing Potential interface
pot = MorsePotential(m)
pot.fit(res.points, res.energies)
np.testing.assert_array_almost_equal([pot.alpha, pot.r_0],
[2.235, 0.720],
decimal=3)
np.testing.assert_array_almost_equal([pot.d_e, pot.m_shift],
[0.2107, -1.1419],
decimal=3)
def setUp(self):
super().setUp()
self.driver = PySCFDriver(
atom="H .0 .0 .0; H .0 .0 0.75",
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis="sto3g",
)
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
# pylint: disable=unused-argument
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values[0][0], 2.0)
self.k = 99
self._numpy_eigensolver_factory = NumPyEigensolverFactory(
filter_criterion=filter_criterion, k=self.k)
def setUp(self):
super().setUp()
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitNatureError:
self.skipTest('PYSCF driver does not appear to be installed')
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
# pylint: disable=unused-argument
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values[0][0], 2.)
self.k = 99
self._numpy_eigensolver_factory = NumPyEigensolverFactory(
filter_criterion=filter_criterion, k=self.k)
def test_h2_bopes_sampler_with_factory(self):
"""Test BOPES Sampler with Factory"""
quantum_instance = QuantumInstance(
backend=qiskit.providers.aer.Aer.get_backend(
"aer_simulator_statevector"),
seed_simulator=self.seed,
seed_transpiler=self.seed,
)
# Molecule
distance1 = partial(Molecule.absolute_distance, atom_pair=(1, 0))
molecule = Molecule(
geometry=[("H", [0.0, 0.0, 0.0]), ("H", [0.0, 0.0, 0.6])],
degrees_of_freedom=[distance1],
)
driver = ElectronicStructureMoleculeDriver(
molecule, driver_type=ElectronicStructureDriverType.PYSCF)
problem = ElectronicStructureProblem(driver)
converter = QubitConverter(ParityMapper())
solver = GroundStateEigensolver(
converter, VQEUCCFactory(quantum_instance=quantum_instance))
sampler = BOPESSampler(solver,
bootstrap=True,
num_bootstrap=None,
extrapolator=None)
result = sampler.sample(problem, list(np.linspace(0.6, 0.8, 4)))
ref_points = [0.6, 0.6666666666666666, 0.7333333333333334, 0.8]
ref_energies = [
-1.1162853926251162,
-1.1327033478688526,
-1.137302817836066,
-1.1341458916990401,
]
np.testing.assert_almost_equal(result.points, ref_points, decimal=3)
np.testing.assert_almost_equal(result.energies,
ref_energies,
decimal=3)
def test_vqe_bootstrap(self):
"""Test with VQE and bootstrapping."""
qubit_converter = QubitConverter(JordanWignerMapper())
quantum_instance = QuantumInstance(
backend=qiskit.providers.aer.Aer.get_backend(
"aer_simulator_statevector"),
seed_simulator=self.seed,
seed_transpiler=self.seed,
)
solver = VQE(quantum_instance=quantum_instance)
vqe_gse = GroundStateEigensolver(qubit_converter, solver)
distance1 = partial(Molecule.absolute_distance, atom_pair=(1, 0))
mol = Molecule(
geometry=[("H", [0.0, 0.0, 0.0]), ("H", [0.0, 0.0, 0.6])],
degrees_of_freedom=[distance1],
)
driver = ElectronicStructureMoleculeDriver(
mol, driver_type=ElectronicStructureDriverType.PYSCF)
es_problem = ElectronicStructureProblem(driver)
points = list(np.linspace(0.6, 0.8, 4))
bopes = BOPESSampler(vqe_gse,
bootstrap=True,
num_bootstrap=None,
extrapolator=None)
result = bopes.sample(es_problem, points)
ref_points = [0.6, 0.6666666666666666, 0.7333333333333334, 0.8]
ref_energies = [
-1.1162738,
-1.1326904,
-1.1372876,
-1.1341292,
]
np.testing.assert_almost_equal(result.points, ref_points)
np.testing.assert_almost_equal(result.energies, ref_energies)
def get_qubit_op(self, dist, mapper='jw'):
# Use PySCF, a classical computational chemistry software
# package, to compute the one-body and two-body integrals in
# electronic-orbital basis, necessary to form the Fermionic operator
driver = PySCFDriver(atom=self.molecule_name + str(dist),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
molecule = driver.run()
es_problem = ElectronicStructureProblem(driver)
if mapper == 'jw':
qubit_converter = QubitConverter(mapper=JordanWignerMapper())
elif mapper == 'parity':
qubit_converter = QubitConverter(mapper=ParityMapper(),
two_qubit_reduction=True)
#second_q_ops = es_problem.second_q_ops()
#num_particles = es_problem.num_particles
#molecule_data = es_problem.molecule_data
#electronic_operator = second_q_ops[0]
return es_problem, qubit_converter, molecule.nuclear_repulsion_energy
class TestHoppingOpsBuilder(QiskitNatureTestCase):
"""Tests Hopping Operators builder."""
def setUp(self):
super().setUp()
algorithm_globals.random_seed = 8
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitNatureError:
self.skipTest('PYSCF driver does not appear to be installed')
self.qubit_converter = QubitConverter(JordanWignerMapper())
self.electronic_structure_problem = ElectronicStructureProblem(
self.driver)
self.electronic_structure_problem.second_q_ops()
self.q_molecule = self.electronic_structure_problem.molecule_data
def test_build_hopping_operators(self):
"""Tests that the correct hopping operator is built from QMolecule."""
# TODO extract it somewhere
expected_hopping_operators = ({
'E_0':
PauliSumOp(SparsePauliOp(
[[True, True, False, False, False, False, False, False],
[True, True, False, False, False, True, False, False],
[True, True, False, False, True, False, False, False],
[True, True, False, False, True, True, False, False]],
coeffs=[1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j]),
coeff=1.0),
'Edag_0':
PauliSumOp(SparsePauliOp(
[[True, True, False, False, False, False, False, False],
[True, True, False, False, False, True, False, False],
[True, True, False, False, True, False, False, False],
[True, True, False, False, True, True, False, False]],
coeffs=[-1. + 0.j, 0. - 1.j, 0. + 1.j, -1. + 0.j]),
coeff=1.0),
'E_1':
PauliSumOp(SparsePauliOp(
[[False, False, True, True, False, False, False, False],
[False, False, True, True, False, False, False, True],
[False, False, True, True, False, False, True, False],
[False, False, True, True, False, False, True, True]],
coeffs=[1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j]),
coeff=1.0),
'Edag_1':
PauliSumOp(SparsePauliOp(
[[False, False, True, True, False, False, False, False],
[False, False, True, True, False, False, False, True],
[False, False, True, True, False, False, True, False],
[False, False, True, True, False, False, True, True]],
coeffs=[-1. + 0.j, 0. - 1.j, 0. + 1.j, -1. + 0.j]),
coeff=1.0),
'E_2':
PauliSumOp(SparsePauliOp(
[[True, True, True, True, False, False, False, False],
[True, True, True, True, False, False, False, True],
[True, True, True, True, False, False, True, False],
[True, True, True, True, False, False, True, True],
[True, True, True, True, False, True, False, False],
[True, True, True, True, False, True, False, True],
[True, True, True, True, False, True, True, False],
[True, True, True, True, False, True, True, True],
[True, True, True, True, True, False, False, False],
[True, True, True, True, True, False, False, True],
[True, True, True, True, True, False, True, False],
[True, True, True, True, True, False, True, True],
[True, True, True, True, True, True, False, False],
[True, True, True, True, True, True, False, True],
[True, True, True, True, True, True, True, False],
[True, True, True, True, True, True, True, True]],
coeffs=[
1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j, 0. - 1.j,
-1. + 0.j, 1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j,
-1. + 0.j, 0. + 1.j, 1. + 0.j, 0. - 1.j, 0. + 1.j, 1. + 0.j
]),
coeff=1.0),
'Edag_2':
PauliSumOp(SparsePauliOp(
[[True, True, True, True, False, False, False, False],
[True, True, True, True, False, False, False, True],
[True, True, True, True, False, False, True, False],
[True, True, True, True, False, False, True, True],
[True, True, True, True, False, True, False, False],
[True, True, True, True, False, True, False, True],
[True, True, True, True, False, True, True, False],
[True, True, True, True, False, True, True, True],
[True, True, True, True, True, False, False, False],
[True, True, True, True, True, False, False, True],
[True, True, True, True, True, False, True, False],
[True, True, True, True, True, False, True, True],
[True, True, True, True, True, True, False, False],
[True, True, True, True, True, True, False, True],
[True, True, True, True, True, True, True, False],
[True, True, True, True, True, True, True, True]],
coeffs=[
1. + 0.j, 0. + 1.j, 0. - 1.j, 1. + 0.j, 0. + 1.j,
-1. + 0.j, 1. + 0.j, 0. + 1.j, 0. - 1.j, 1. + 0.j,
-1. + 0.j, 0. - 1.j, 1. + 0.j, 0. + 1.j, 0. - 1.j, 1. + 0.j
]),
coeff=1.0)
}, {
'E_0': [],
'Edag_0': [],
'E_1': [],
'Edag_1': [],
'E_2': [],
'Edag_2': []
}, {
'E_0': ((0, ), (1, )),
'Edag_0': ((1, ), (0, )),
'E_1': ((2, ), (3, )),
'Edag_1': ((3, ), (2, )),
'E_2': ((0, 2), (1, 3)),
'Edag_2': ((1, 3), (0, 2))
})
hopping_operators = _build_qeom_hopping_ops(self.q_molecule,
self.qubit_converter)
self.assertEqual(hopping_operators, expected_hopping_operators)
