def test_uccsd_hf_aer_qasm(self):
""" uccsd hf test with Aer qasm_simulator. """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
backend = Aer.get_backend('qasm_simulator')
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
ansatz = self._prepare_uccsd_hf(self.qubit_converter)
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(ansatz=ansatz,
optimizer=optimizer,
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def test_uccsd_hf_qUCCD0full(self):
"""singlet full uccd test"""
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles,
self.qubit_converter)
# TODO: add `full` option
ansatz = SUCCD(
self.qubit_converter,
self.num_particles,
self.num_spin_orbitals,
initial_state=initial_state,
)
solver = VQE(
ansatz=ansatz,
optimizer=optimizer,
quantum_instance=QuantumInstance(
backend=BasicAer.get_backend("statevector_simulator")),
)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy_UCCD0full,
places=6)
def test_eval_op_qasm_aer(self):
"""Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53."""
try:
# pylint: disable=import-outside-toplevel
# pylint: disable=unused-import
from qiskit import Aer
backend = Aer.get_backend("aer_simulator")
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(f"Aer doesn't appear to be installed. Error: '{str(ex)}'")
return
solver = VQEUCCFactory(
optimizer=SLSQP(maxiter=100),
expectation=AerPauliExpectation(),
include_custom=True,
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
),
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
res_qasm = calc.solve(self.electronic_structure_problem)
hamiltonian = self.electronic_structure_problem.second_q_ops()[0]
qubit_op = self.qubit_converter.map(hamiltonian)
ansatz = solver.get_solver(self.electronic_structure_problem, self.qubit_converter).ansatz
circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point)
mean = calc.evaluate_operators(circuit, qubit_op)
self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real)
def test_uccsd_hf_qpUCCD(self):
"""paired uccd test"""
self.skipTest(
"Temporarily skip test until the changes done by "
"https://github.com/Qiskit/qiskit-terra/pull/7551 are handled properly."
)
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles,
self.qubit_converter)
ansatz = PUCCD(
self.qubit_converter,
self.num_particles,
self.num_spin_orbitals,
initial_state=initial_state,
)
solver = VQE(
ansatz=ansatz,
optimizer=optimizer,
quantum_instance=QuantumInstance(
backend=BasicAer.get_backend("statevector_simulator")),
)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy_pUCCD,
places=6)
def test_eval_op_qasm_aer(self):
"""Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53."""
backend = qiskit.providers.aer.Aer.get_backend("aer_simulator")
solver = VQEUCCFactory(
optimizer=SLSQP(maxiter=100),
expectation=AerPauliExpectation(),
include_custom=True,
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
),
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
res_qasm = calc.solve(self.electronic_structure_problem)
hamiltonian = self.electronic_structure_problem.second_q_ops()[
self.electronic_structure_problem.main_property_name]
qubit_op = self.qubit_converter.map(hamiltonian)
ansatz = solver.get_solver(self.electronic_structure_problem,
self.qubit_converter).ansatz
circuit = ansatz.assign_parameters(res_qasm.raw_result.optimal_point)
mean = calc.evaluate_operators(circuit, qubit_op)
self.assertAlmostEqual(res_qasm.eigenenergies[0], mean[0].real)
def test_print_result(self):
"""Regression test against #198 and general issues with printing results."""
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
with contextlib.redirect_stdout(io.StringIO()) as out:
print(res)
# do NOT change the below! Lines have been truncated as to not force exact numerical matches
expected = """\
=== GROUND STATE ENERGY ===
* Electronic ground state energy (Hartree): -1.857
- computed part: -1.857
~ Nuclear repulsion energy (Hartree): 0.719
> Total ground state energy (Hartree): -1.137
=== MEASURED OBSERVABLES ===
0: # Particles: 2.000 S: 0.000 S^2: 0.000 M: 0.000
=== DIPOLE MOMENTS ===
~ Nuclear dipole moment (a.u.): [0.0 0.0 1.38
0:
* Electronic dipole moment (a.u.): [0.0 0.0 -1.38
- computed part: [0.0 0.0 -1.38
> Dipole moment (a.u.): [0.0 0.0 0.0] Total: 0.
(debye): [0.0 0.0 0.0] Total: 0.
"""
for truth, expected in zip(out.getvalue().split("\n"),
expected.split("\n")):
assert truth.strip().startswith(expected.strip())
def test_uccsd_hf_aer_statevector(self):
""" uccsd hf test with Aer statevector """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
ansatz = self._prepare_uccsd_hf(self.qubit_converter)
optimizer = SLSQP(maxiter=100)
solver = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=QuantumInstance(backend=backend))
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0],
self.reference_energy,
places=6)
def test_uccsd_hf_aer_qasm_snapshot(self):
"""uccsd hf test with Aer qasm simulator snapshot."""
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
backend = Aer.get_backend("aer_simulator")
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(f"Aer doesn't appear to be installed. Error: '{str(ex)}'")
return
ansatz = self._prepare_uccsd_hf(self.qubit_converter)
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(
ansatz=ansatz,
optimizer=optimizer,
expectation=AerPauliExpectation(),
quantum_instance=QuantumInstance(backend=backend),
)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=3)
def test_npme(self):
"""Test NumPyMinimumEigensolver"""
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
def test_vqe_uccsd(self):
""" Test VQE UCCSD case """
solver = VQEUCCFactory(
quantum_instance=QuantumInstance(BasicAer.get_backend('statevector_simulator')),
ansatz=UCC(excitations='d'),
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
def test_total_dipole(self):
"""Regression test against #198.
An issue with calculating the dipole moment that had division None/float.
"""
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_dipole_moment_in_debye[0], 0.0, places=1)
def test_vqe_ucc_custom(self):
"""Test custom ansatz in Factory use case"""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
def _setup_evaluation_operators(self):
# first we run a ground state calculation
solver = VQEUCCFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
# now we decide that we want to evaluate another operator
# for testing simplicity, we just use some pre-constructed auxiliary operators
_, *aux_ops = self.qubit_converter.convert_match(
self.electronic_structure_problem.second_q_ops())
return calc, res, aux_ops
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 test_default_initial_point(self):
"""Test when using the default initial point."""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
np.testing.assert_array_equal(solver.initial_point.to_numpy_array(),
[0.0, 0.0, 0.0])
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
def test_uccsd_hf(self):
""" uccsd hf test """
ansatz = self._prepare_uccsd_hf(self.qubit_converter)
optimizer = SLSQP(maxiter=100)
backend = BasicAer.get_backend('statevector_simulator')
solver = VQE(ansatz=ansatz, optimizer=optimizer,
quantum_instance=QuantumInstance(backend=backend))
gsc = GroundStateEigensolver(self.qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6)
def _setup_evaluation_operators(self):
# first we run a ground state calculation
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
# now we decide that we want to evaluate another operator
# for testing simplicity, we just use some pre-constructed auxiliary operators
second_q_ops = self.electronic_structure_problem.second_q_ops()
# Remove main op to leave just aux ops
second_q_ops.pop(self.electronic_structure_problem.main_property_name)
aux_ops_dict = self.qubit_converter.convert_match(second_q_ops)
return calc, res, aux_ops_dict
def test_dict_based_aux_ops(self):
"""Test the `test_dict_based_aux_ops` variant"""
try:
settings.dict_aux_operators = True
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
self.assertTrue(
np.all(isinstance(aux_op, dict) for aux_op in res.aux_operator_eigenvalues)
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["ParticleNumber"][0], 2.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["ParticleNumber"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["AngularMomentum"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["AngularMomentum"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["Magnetization"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["Magnetization"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentX"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentX"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentY"][0], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentY"][1], 0.0, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentZ"][0], -1.3889487, places=6
)
self.assertAlmostEqual(
res.aux_operator_eigenvalues[0]["DipoleMomentZ"][1], 0.0, places=6
)
finally:
settings.dict_aux_operators = False
def test_vqe_ucc_factory_with_user_initial_point(self):
"""Test VQEUCCFactory when using it with a user defined initial point."""
initial_point = np.asarray(
[1.28074029e-19, 5.92226076e-08, 1.11762559e-01])
solver = VQEUCCFactory(
quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")),
initial_point=initial_point,
optimizer=SLSQP(maxiter=1),
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
np.testing.assert_array_almost_equal(res.raw_result.optimal_point,
initial_point)
def test_aux_ops_reusability(self):
""" Test that the auxiliary operators can be reused """
# Regression test against #1475
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.qubit_converter, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = [build_ferm_op_from_ints(h_1, h_2)]
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.electronic_structure_problem)
assert all(frozenset(a.to_list()) == frozenset(b.to_list())
for a, b in zip(aux_ops, aux_ops_copy))
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 test_vqe_uvccsd_with_callback(self):
"""Test VQE UVCCSD with callback."""
def cb_callback(nfev, parameters, energy, stddev):
print(f"iterations {nfev}: energy: {energy}")
optimizer = COBYLA(maxiter=5000)
quantum_instance = QuantumInstance(
backend=qiskit.BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
solver = VQEUVCCFactory(quantum_instance=quantum_instance,
optimizer=optimizer,
callback=cb_callback)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, "sd")
with contextlib.redirect_stdout(io.StringIO()) as out:
results = esc.solve(self.vibrational_problem)
for idx, energy in enumerate(self.reference_energies):
self.assertAlmostEqual(results.computed_vibrational_energies[idx],
energy,
places=1)
for idx, line in enumerate(out.getvalue().split("\n")):
if line.strip():
self.assertTrue(
line.startswith(f"iterations {idx+1}: energy: "))
def test_vqe_uccsd_with_callback(self):
"""Test VQE UCCSD with callback."""
def callback(nfev, parameters, energy, stddev):
# pylint: disable=unused-argument
print(f"iterations {nfev}: energy: {energy}")
solver = VQEUCCFactory(
quantum_instance=QuantumInstance(BasicAer.get_backend("statevector_simulator")),
callback=callback,
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
with contextlib.redirect_stdout(io.StringIO()) as out:
res = calc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(res.total_energies[0], self.reference_energy, places=6)
for idx, line in enumerate(out.getvalue().split("\n")):
if line.strip():
self.assertTrue(line.startswith(f"iterations {idx+1}: energy: "))
def test_vqe_ucc_factory_with_mp2(self):
"""Test when using MP2InitialPoint to generate the initial point."""
informed_start = MP2InitialPoint()
solver = VQEUCCFactory(
quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")),
initial_point=informed_start,
)
calc = GroundStateEigensolver(self.qubit_converter, solver)
res = calc.solve(self.electronic_structure_problem)
np.testing.assert_array_almost_equal(
solver.initial_point.to_numpy_array(), [0.0, 0.0, -0.07197145])
self.assertAlmostEqual(res.total_energies[0],
self.reference_energy,
places=6)
def _solve_with_vqe_mes(self, converter: QubitConverter):
solver = VQEUCCFactory(self.quantum_instance)
gsc = GroundStateEigensolver(converter, solver)
esc = QEOM(gsc, "sd")
results = esc.solve(self.electronic_structure_problem)
for idx, energy in enumerate(self.reference_energies):
self.assertAlmostEqual(results.computed_energies[idx],
energy,
places=4)
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_uccsd_hf_qasm(self):
""" uccsd hf test with qasm_simulator. """
qubit_converter = QubitConverter(ParityMapper())
ansatz = self._prepare_uccsd_hf(qubit_converter)
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(ansatz=ansatz, optimizer=optimizer,
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
gsc = GroundStateEigensolver(qubit_converter, solver)
result = gsc.solve(self.electronic_structure_problem)
self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def test_numpy_mes(self):
"""Test NumPyMinimumEigenSolver with QEOM"""
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, "sd")
results = esc.solve(self.electronic_structure_problem)
for idx, energy in enumerate(self.reference_energies):
self.assertAlmostEqual(results.computed_energies[idx],
energy,
places=4)
def test_vqe_mes(self):
"""Test VQEUCCSDFactory with QEOM"""
solver = VQEUCCFactory(self.quantum_instance)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, "sd")
results = esc.solve(self.electronic_structure_problem)
for idx in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_energies[idx],
self.reference_energies[idx],
places=4)
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)