def setUp(self):
super().setUp()
try:
PySCFDriver(atom=self.lih)
except QiskitNatureError:
self.skipTest('PySCF driver does not appear to be installed')
def setUp(self):
super().setUp()
PySCFDriver(atom=self.lih)
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# --- Exact copy of sample code ----------------------------------------
from qiskit_nature import FermionicOperator
from qiskit_nature.drivers import PySCFDriver, UnitsType
from qiskit.opflow import TwoQubitReduction
# Use PySCF, a classical computational chemistry software
# package, to compute the one-body and two-body integrals in
# molecular-orbital basis, necessary to form the Fermionic operator
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
molecule = driver.run()
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
# Build the qubit operator, which is the input to the VQE algorithm
ferm_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
map_type = 'PARITY'
qubit_op = ferm_op.mapping(map_type)
qubit_op = TwoQubitReduction(
num_particles=num_particles).convert(qubit_op)
num_qubits = qubit_op.num_qubits
# setup a classical optimizer for VQE
from qiskit.algorithms.optimizers import L_BFGS_B
optimizer = L_BFGS_B()
# setup the initial state for the variational form
from qiskit_nature.circuit.library import HartreeFock
init_state = HartreeFock(num_spin_orbitals, num_particles)
# setup the variational form for VQE
from qiskit.circuit.library import TwoLocal
var_form = TwoLocal(num_qubits, ['ry', 'rz'], 'cz')
# add the initial state
var_form.compose(init_state, front=True)
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
# setup and run VQE
from qiskit.algorithms import VQE
algorithm = VQE(var_form,
optimizer=optimizer,
quantum_instance=backend)
result = algorithm.compute_minimum_eigenvalue(qubit_op)
print(result.eigenvalue.real)
# ----------------------------------------------------------------------
self.assertAlmostEqual(result.eigenvalue.real,
-1.8572750301938803,
places=6)
class TestAdaptVQEUCCSD(QiskitNatureTestCase):
""" Test Adaptive VQE with UCCSD"""
def setUp(self):
super().setUp()
# np.random.seed(50)
self.seed = 50
algorithm_globals.random_seed = self.seed
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
molecule = self.driver.run()
self.num_particles = molecule.num_alpha + molecule.num_beta
self.num_spin_orbitals = molecule.num_orbitals * 2
fer_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
map_type = 'PARITY'
qubit_op = fer_op.mapping(map_type)
self.qubit_op = TwoQubitReduction(
num_particles=self.num_particles).convert(qubit_op)
self.num_qubits = self.qubit_op.num_qubits
self.init_state = HartreeFock(self.num_spin_orbitals,
self.num_particles)
self.var_form_base = None
def test_uccsd_adapt(self):
""" UCCSD test for adaptive features """
self.var_form_base = UCCSD(self.num_spin_orbitals,
self.num_particles,
initial_state=self.init_state)
self.var_form_base.manage_hopping_operators()
# assert that the excitation pool exists
self.assertIsNotNone(self.var_form_base.excitation_pool)
# assert that the hopping ops list has been reset to be empty
self.assertEqual(self.var_form_base._hopping_ops, [])
def test_vqe_adapt(self):
""" AdaptVQE test """
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
class CustomFactory(VQEUCCSDFactory):
"""A custom MESFactory"""
def get_solver(self, transformation):
num_orbitals = transformation.molecule_info['num_orbitals']
num_particles = transformation.molecule_info['num_particles']
initial_state = HartreeFock(num_orbitals, num_particles)
var_form = UCCSD(num_orbitals,
num_particles,
initial_state=initial_state)
vqe = VQE(var_form=var_form,
quantum_instance=self._quantum_instance,
optimizer=L_BFGS_B())
return vqe
algorithm = AdaptVQE(FermionicTransformation(),
solver=CustomFactory(QuantumInstance(backend)),
threshold=0.00001,
delta=0.1,
max_iterations=1)
result = algorithm.solve(driver=self.driver)
self.assertEqual(result.num_iterations, 1)
self.assertEqual(result.finishing_criterion,
'Maximum number of iterations reached')
algorithm = AdaptVQE(FermionicTransformation(),
solver=CustomFactory(QuantumInstance(backend)),
threshold=0.00001,
delta=0.1)
result = algorithm.solve(driver=self.driver)
self.assertAlmostEqual(result.electronic_energies[0],
-1.85727503,
places=2)
self.assertEqual(result.num_iterations, 2)
self.assertAlmostEqual(result.final_max_gradient, 0.0, places=5)
self.assertEqual(result.finishing_criterion, 'Threshold converged')
def test_vqe_adapt_check_cyclicity(self):
""" AdaptVQE index cycle detection """
param_list = [
([1, 1], True),
([1, 11], False),
([11, 1], False),
([1, 12], False),
([12, 2], False),
([1, 1, 1], True),
([1, 2, 1], False),
([1, 2, 2], True),
([1, 2, 21], False),
([1, 12, 2], False),
([11, 1, 2], False),
([1, 2, 1, 1], True),
([1, 2, 1, 2], True),
([1, 2, 1, 21], False),
([11, 2, 1, 2], False),
([1, 11, 1, 111], False),
([11, 1, 111, 1], False),
([1, 2, 3, 1, 2, 3], True),
([1, 2, 3, 4, 1, 2, 3], False),
([11, 2, 3, 1, 2, 3], False),
([1, 2, 3, 1, 2, 31], False),
([1, 2, 3, 4, 1, 2, 3, 4], True),
([11, 2, 3, 4, 1, 2, 3, 4], False),
([1, 2, 3, 4, 1, 2, 3, 41], False),
([1, 2, 3, 4, 5, 1, 2, 3, 4], False),
]
for seq, is_cycle in param_list:
with self.subTest(msg="Checking index cyclicity in:", seq=seq):
self.assertEqual(is_cycle, AdaptVQE._check_cyclicity(seq))
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel,redefined-builtin
def print(*args):
""" overloads print to log values """
if args:
self.log.debug(args[0], *args[1:])
# --- Exact copy of sample code ----------------------------------------
from qiskit_nature.drivers import PySCFDriver, UnitsType
from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem
# 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='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
problem = ElectronicStructureProblem(driver)
# generate the second-quantized operators
second_q_ops = problem.second_q_ops()
main_op = second_q_ops[0]
num_particles = (problem.molecule_data_transformed.num_alpha,
problem.molecule_data_transformed.num_beta)
num_spin_orbitals = 2 * problem.molecule_data.num_molecular_orbitals
# setup the classical optimizer for VQE
from qiskit.algorithms.optimizers import L_BFGS_B
optimizer = L_BFGS_B()
# setup the mapper and qubit converter
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.operators.second_quantization.qubit_converter import QubitConverter
mapper = ParityMapper()
converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
# map to qubit operators
qubit_op = converter.convert(main_op, num_particles=num_particles)
# setup the initial state for the ansatz
from qiskit_nature.circuit.library import HartreeFock
init_state = HartreeFock(num_spin_orbitals, num_particles, converter)
# setup the ansatz for VQE
from qiskit.circuit.library import TwoLocal
ansatz = TwoLocal(num_spin_orbitals, ['ry', 'rz'], 'cz')
# add the initial state
ansatz.compose(init_state, front=True)
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
# setup and run VQE
from qiskit.algorithms import VQE
algorithm = VQE(ansatz, optimizer=optimizer, quantum_instance=backend)
result = algorithm.compute_minimum_eigenvalue(qubit_op)
print(result.eigenvalue.real)
electronic_structure_result = problem.interpret(result)
print(electronic_structure_result)
# ----------------------------------------------------------------------
self.assertAlmostEqual(result.eigenvalue.real,
-1.8572750301938803,
places=6)
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])
f_t = FermionicTransformation()
driver = PySCFDriver(molecule=m)
qubitop, _ = f_t.transform(driver)
# Quantum Instance:
shots = 1
backend = 'statevector_simulator'
quantum_instance = QuantumInstance(BasicAer.get_backend(backend), shots=shots)
quantum_instance.run_config.seed_simulator = seed
quantum_instance.compile_config['seed_transpiler'] = seed
# Variational form
i_state = HartreeFock(num_orbitals=f_t._molecule_info['num_orbitals'],
qubit_mapping=f_t._qubit_mapping,
two_qubit_reduction=f_t._two_qubit_reduction,
num_particles=f_t._molecule_info['num_particles'],
sq_list=f_t._molecule_info['z2_symmetries'].sq_list
)
var_form = RealAmplitudes(qubitop.num_qubits, reps=1, entanglement='full',
skip_unentangled_qubits=False)
var_form.compose(i_state, front=True)
# Classical optimizer:
# Analytic Quantum Gradient Descent (AQGD) (with Epochs)
aqgd_max_iter = [10] + [1] * 100
aqgd_eta = [1e0] + [1.0 / k for k in range(1, 101)]
aqgd_momentum = [0.5] + [0.5] * 100
optimizer = AQGD(maxiter=aqgd_max_iter,
eta=aqgd_eta,
momentum=aqgd_momentum,
tol=1e-6,
averaging=4)
# Min Eigensolver: VQE
solver = VQE(var_form=var_form,
optimizer=optimizer,
quantum_instance=quantum_instance,
expectation=PauliExpectation())
me_gss = GroundStateEigensolver(f_t, solver)
# BOPES sampler
sampler = BOPESSampler(gss=me_gss)
# absolute internuclear distance in Angstrom
points = [0.7, 1.0, 1.3]
results = sampler.sample(driver, 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)
