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('qasm_simulator')
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
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_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_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('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=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_uccsd_hf_qpUCCD(self):
""" paired uccd test """
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_uccsd_hf_qpUCCD(self):
""" paired uccd test """
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
self.fermionic_transformation.molecule_info['num_orbitals'],
self.fermionic_transformation.molecule_info['num_particles'],
qubit_mapping=self.fermionic_transformation._qubit_mapping,
two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction)
var_form = UCCSD(
num_orbitals=self.fermionic_transformation.molecule_info['num_orbitals'],
num_particles=self.fermionic_transformation.molecule_info['num_particles'],
active_occupied=None, active_unoccupied=None,
initial_state=initial_state,
qubit_mapping=self.fermionic_transformation._qubit_mapping,
two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction,
num_time_slices=1,
shallow_circuit_concat=False,
method_doubles='pucc',
excitation_type='d'
)
solver = VQE(var_form=var_form, optimizer=optimizer,
quantum_instance=QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator')))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.total_energies[0], self.reference_energy_pUCCD, places=6)
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_ucc_custom(self):
""" Test custom ansatz in Factory use case """
solver = VQEUCCFactory(
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 = VQEUCCSDFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = GroundStateEigensolver(self.transformation, solver)
res = calc.solve(self.driver)
# now we decide that we want to evaluate another operator
# for testing simplicity, we just use some pre-constructed auxiliary operators
_, aux_ops = self.transformation.transform(self.driver)
return calc, res, aux_ops
def test_uccsd_hf(self):
""" uccsd hf test """
backend = BasicAer.get_backend('statevector_simulator')
solver = VQE(var_form=self.var_form, optimizer=self.optimizer,
quantum_instance=QuantumInstance(backend=backend))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
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(
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 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 _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_aux_ops_reusability(self):
""" Test that the auxiliary operators can be reused """
# Regression test against #1475
solver = NumPyMinimumEigensolverFactory()
calc = GroundStateEigensolver(self.transformation, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = [FermionicOperator(h_1, h_2)]
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.driver, aux_ops)
assert all(a == b for a, b in zip(aux_ops, aux_ops_copy))
def test_uccsd_hf_qasm(self):
""" uccsd hf test with qasm_simulator. """
backend = BasicAer.get_backend('qasm_simulator')
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(var_form=self.var_form, optimizer=optimizer,
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def test_h2_bopes_sampler(self):
"""Test BOPES Sampler on H2"""
seed = 50
algorithm_globals.random_seed = seed
# Molecule
dof = partial(Molecule.absolute_distance, atom_pair=(1, 0))
m = Molecule(geometry=[['H', [0., 0., 1.]], ['H', [0., 0.45, 1.]]],
degrees_of_freedom=[dof])
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
driver = PySCFDriver(molecule=m)
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_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
solver = VQE(var_form=self.var_form, optimizer=self.optimizer,
quantum_instance=QuantumInstance(backend=backend))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.total_energies[0], self.reference_energy, places=6)
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.]],
['H', [1., 0., 0.]],
],
degrees_of_freedom=[stretch],
masses=[1.6735328E-27, 1.6735328E-27])
f_t = FermionicTransformation()
driver = PySCFDriver(molecule=m)
f_t.transform(driver)
solver = NumPyMinimumEigensolver()
me_gss = GroundStateEigensolver(f_t, solver)
# Run BOPESSampler with exact eigensolution
points = np.arange(0.45, 5.3, 0.3)
sampler = BOPESSampler(gss=me_gss)
res = sampler.sample(driver, 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 test_return_groundstate(self):
"""Test the VQEClient yields a ground state solver that returns the ground state."""
for use_deprecated in [False, True]:
vqe, _ = self.get_standard_program(use_deprecated=use_deprecated)
qubit_converter = QubitConverter(JordanWignerMapper())
gss = GroundStateEigensolver(qubit_converter, vqe)
self.assertTrue(gss.returns_groundstate)
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_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 _run_driver(driver,
transformation=FermionicTransformationType.FULL,
qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True):
fermionic_transformation = \
FermionicTransformation(transformation=transformation,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
freeze_core=freeze_core,
orbital_reduction=[])
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(fermionic_transformation, solver)
result = gsc.solve(driver)
return result
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_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 in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx],
places=4)
def test_vqe_mes(self):
""" Test VQEUCCSDFactory with QEOM """
solver = VQEUCCSDFactory(self.quantum_instance)
gsc = GroundStateEigensolver(self.transformation, solver)
esc = QEOM(gsc, 'sd')
results = esc.solve(self.driver)
for idx in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx],
places=4)
def test_numpy_mes(self):
""" Test NumPyMinimumEigenSolver with QEOM """
solver = NumPyMinimumEigensolver()
gsc = GroundStateEigensolver(self.transformation, solver)
esc = QEOM(gsc, 'sd')
results = esc.solve(self.driver)
for idx in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_energies[idx], self.reference_energies[idx],
places=4)
def test_numpy_mes(self):
""" Test with NumPyMinimumEigensolver """
solver = NumPyMinimumEigensolverFactory(use_default_filter_criterion=True)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, 'sd')
results = esc.solve(self.vibrational_problem)
for idx in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_vibrational_energies[idx],
self.reference_energies[idx],
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_vqe_uvccsd_factory(self):
""" Test with VQE plus UVCCSD """
optimizer = COBYLA(maxiter=5000)
solver = VQEUVCCFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator')),
optimizer=optimizer)
gsc = GroundStateEigensolver(self.qubit_converter, solver)
esc = QEOM(gsc, 'sd')
results = esc.solve(self.vibrational_problem)
for idx in range(len(self.reference_energies)):
self.assertAlmostEqual(results.computed_vibrational_energies[idx],
self.reference_energies[idx],
places=1)
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
optimizer = SPSA(maxiter=200, last_avg=5)
solver = VQE(var_form=self.var_form, optimizer=optimizer,
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed))
gsc = GroundStateEigensolver(self.fermionic_transformation, solver)
result = gsc.solve(self.driver)
self.assertAlmostEqual(result.total_energies[0], -1.138, places=2)
def test_eval_op_qasm(self):
"""Regression tests against https://github.com/Qiskit/qiskit-nature/issues/53."""
solver = VQEUCCFactory(
optimizer=SLSQP(maxiter=100),
expectation=PauliExpectation(),
quantum_instance=QuantumInstance(
backend=BasicAer.get_backend('qasm_simulator'),
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)
