def get_solver(self, problem, qubit_converter):
particle_number = cast(
ParticleNumber,
problem.grouped_property_transformed.get_property(
ParticleNumber),
)
num_spin_orbitals = particle_number.num_spin_orbitals
num_particles = (particle_number.num_alpha,
particle_number.num_beta)
initial_state = HartreeFock(num_spin_orbitals, num_particles,
qubit_converter)
ansatz = UCC(
qubit_converter=qubit_converter,
num_particles=num_particles,
num_spin_orbitals=num_spin_orbitals,
excitations="d",
initial_state=initial_state,
)
vqe = VQE(
ansatz=ansatz,
quantum_instance=self.minimum_eigensolver.quantum_instance,
optimizer=L_BFGS_B(),
)
return vqe
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_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_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_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_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 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 run(self):
numpy_solver = NumPyMinimumEigensolver()
distances = np.arange(0.3, 2.0, 0.05)
exact_energies = []
vqe_energies = []
n = len(distances)
i = 1
for dist in distances:
print("Distance %d/%d" % (i, n))
i += 1
es_problem, qubit_converter, nuclear_repulsion_energy = self.get_qubit_op(
dist)
second_q_ops = es_problem.second_q_ops()
main_op = qubit_converter.convert(
second_q_ops[0],
num_particles=es_problem.num_particles,
sector_locator=es_problem.symmetry_sector_locator)
aux_ops = qubit_converter.convert_match(second_q_ops[1:])
q_molecule_transformed = cast(QMolecule,
es_problem.molecule_data_transformed)
num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals
num_particles = (q_molecule_transformed.num_alpha,
q_molecule_transformed.num_beta)
num_spin_orbitals = 2 * num_molecular_orbitals
# Initial state is Hartree Fock state
initial_state = HartreeFock(num_spin_orbitals, num_particles,
qubit_converter)
# UCCSD ansatz for unitary update
ansatz = UCCSD()
ansatz.qubit_converter = qubit_converter
ansatz.num_particles = num_particles
ansatz.num_spin_orbitals = num_spin_orbitals
ansatz.initial_state = initial_state
self.vqe.ansatz = ansatz
solver = self.vqe
print("Computing minimum eigenvalue...")
# Approximate minimum eigenvalue using VQE
vqe_result = solver.compute_minimum_eigenvalue(main_op)
print(np.real(vqe_result.eigenvalue) + nuclear_repulsion_energy)
#exact_result = numpy_solver.compute_minimum_eigenvalue(main_op)
vqe_energies.append(
np.real(vqe_result.eigenvalue) + nuclear_repulsion_energy)
#exact_energies.append(np.real(exact_result.eigenvalue) + nuclear_repulsion_energy)
#print("Interatomic Distance:", np.round(dist, 2), "VQE Result:", vqe_result, "Exact Energy:", exact_energies[-1])
return (distances, vqe_energies, exact_energies)
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 get_solver(self, problem: ElectronicStructureProblem, # type: ignore[override]
qubit_converter: QubitConverter) -> MinimumEigensolver:
"""Returns a VQE with a UCCSD wavefunction ansatz, based on ``transformation``.
This works only with a ``FermionicTransformation``.
Args:
problem: a class encoding a problem to be solved.
qubit_converter: a class that converts second quantized operator to qubit operator
according to a mapper it is initialized with.
Returns:
A VQE suitable to compute the ground state of the molecule transformed
by ``transformation``.
"""
q_molecule_transformed = cast(QMolecule, problem.molecule_data_transformed)
num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals
num_particles = (q_molecule_transformed.num_alpha, q_molecule_transformed.num_beta)
num_spin_orbitals = 2 * num_molecular_orbitals
initial_state = self.initial_state
if initial_state is None:
initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter)
ansatz = self.ansatz
if ansatz is None:
ansatz = UCCSD()
ansatz.qubit_converter = qubit_converter
ansatz.num_particles = num_particles
ansatz.num_spin_orbitals = num_spin_orbitals
ansatz.initial_state = initial_state
self._vqe.ansatz = ansatz
return self._vqe
def _prepare_uccsd_hf(self, qubit_converter):
initial_state = HartreeFock(self.num_spin_orbitals, self.num_particles,
qubit_converter)
ansatz = UCCSD(qubit_converter,
self.num_particles,
self.num_spin_orbitals,
initial_state=initial_state)
return ansatz
def test_qubits_2_py_h2(self):
""" qubits 2 py h2 test """
num_particles = (1, 1)
converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
converter.force_match(num_particles=num_particles)
state = HartreeFock(4, num_particles, converter)
ref = QuantumCircuit(2)
ref.x(0)
self.assertEqual(state, ref)
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
def test_uccsd_hf_excitations(self):
""" uccsd tapering test using all double excitations """
# initial state
init_state = HartreeFock(
num_orbitals=self.fermionic_transformation.molecule_info['num_orbitals'],
qubit_mapping=self.fermionic_transformation._qubit_mapping,
two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction,
num_particles=self.fermionic_transformation.molecule_info['num_particles'],
sq_list=self.fermionic_transformation.molecule_info['z2_symmetries'].sq_list)
# check singlet excitations
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=init_state,
qubit_mapping=self.fermionic_transformation._qubit_mapping,
two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=self.fermionic_transformation.molecule_info['z2_symmetries'],
shallow_circuit_concat=False,
method_doubles='succ',
excitation_type='d',
skip_commute_test=True)
double_excitations_singlet = var_form._double_excitations
res = TestUCCSDHartreeFock.excitation_lists_comparator(
double_excitations_singlet, self.reference_singlet_double_excitations)
self.assertEqual(res, True)
# check grouped singlet excitations
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=init_state,
qubit_mapping=self.fermionic_transformation._qubit_mapping,
two_qubit_reduction=self.fermionic_transformation._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=self.fermionic_transformation.molecule_info['z2_symmetries'],
shallow_circuit_concat=False,
method_doubles='succ_full',
excitation_type='d',
skip_commute_test=True)
double_excitations_singlet_grouped = var_form._double_excitations_grouped
res_groups = TestUCCSDHartreeFock.group_excitation_lists_comparator(
double_excitations_singlet_grouped, self.reference_singlet_groups)
self.assertEqual(res_groups, True)
def get_solver( # type: ignore[override]
self,
problem: ElectronicStructureProblem,
qubit_converter: QubitConverter,
) -> MinimumEigensolver:
"""Returns a VQE with a UCCSD wavefunction ansatz, based on ``qubit_converter``.
Args:
problem: a class encoding a problem to be solved.
qubit_converter: a class that converts second quantized operator to qubit operator
according to a mapper it is initialized with.
Returns:
A VQE suitable to compute the ground state of the molecule.
"""
driver_result = problem.grouped_property_transformed
particle_number = cast(ParticleNumber, driver_result.get_property(ParticleNumber))
num_spin_orbitals = particle_number.num_spin_orbitals
num_particles = particle_number.num_alpha, particle_number.num_beta
initial_state = self.initial_state
if initial_state is None:
initial_state = HartreeFock(num_spin_orbitals, num_particles, qubit_converter)
ansatz = self.ansatz
if ansatz is None:
ansatz = UCCSD()
ansatz.qubit_converter = qubit_converter
ansatz.num_particles = num_particles
ansatz.num_spin_orbitals = num_spin_orbitals
ansatz.initial_state = initial_state
# TODO: leverage re-usability of VQE after fixing
# https://github.com/Qiskit/qiskit-terra/issues/7093
vqe = VQE(
ansatz=ansatz,
quantum_instance=self.quantum_instance,
optimizer=self.optimizer,
initial_point=self.initial_point,
gradient=self.gradient,
expectation=self.expectation,
include_custom=self.include_custom,
callback=self.callback,
**self._kwargs,
)
return vqe
def test_uccsd_hf_qUCCSD(self):
""" uccsd tapering test using all double excitations """
fermionic_transformation = FermionicTransformation(
transformation=FermionicTransformationType.FULL,
qubit_mapping=FermionicQubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[],
z2symmetry_reduction='auto'
)
qubit_op, _ = fermionic_transformation.transform(self.driver)
# optimizer
optimizer = SLSQP(maxiter=100)
# initial state
init_state = HartreeFock(
num_orbitals=fermionic_transformation.molecule_info['num_orbitals'],
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction,
num_particles=fermionic_transformation.molecule_info['num_particles'],
sq_list=fermionic_transformation.molecule_info['z2_symmetries'].sq_list)
var_form = UCCSD(
num_orbitals=fermionic_transformation.molecule_info['num_orbitals'],
num_particles=fermionic_transformation.molecule_info['num_particles'],
active_occupied=None, active_unoccupied=None,
initial_state=init_state,
qubit_mapping=fermionic_transformation._qubit_mapping,
two_qubit_reduction=fermionic_transformation._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=fermionic_transformation.molecule_info['z2_symmetries'],
shallow_circuit_concat=False,
method_doubles='ucc',
excitation_type='sd',
skip_commute_test=True)
solver = VQE(var_form=var_form, optimizer=optimizer,
quantum_instance=QuantumInstance(
backend=BasicAer.get_backend('statevector_simulator')))
raw_result = solver.compute_minimum_eigenvalue(qubit_op, None)
result = fermionic_transformation.interpret(raw_result)
self.assertAlmostEqual(result.total_energies[0], self.reference_energy_UCCSD, places=6)
def test_qubits_6_py_lih(self):
""" qubits 6 py lih test """
num_particles = (1, 1)
converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
z2symmetries = Z2Symmetries(
symmetries=[Pauli('ZIZIZIZI'),
Pauli('ZZIIZZII')],
sq_paulis=[Pauli('IIIIIIXI'), Pauli('IIIIIXII')],
sq_list=[2, 3],
tapering_values=[1, 1],
)
converter.force_match(num_particles=num_particles,
z2symmetries=z2symmetries)
state = HartreeFock(10, num_particles, converter)
ref = QuantumCircuit(6)
ref.x([0, 1])
self.assertEqual(state, ref)
def test_setters_getters(self):
"""Test Getter/Setter"""
with self.subTest("Quantum Instance"):
self.assertEqual(self._vqe_ucc_factory.quantum_instance,
self.quantum_instance)
self._vqe_ucc_factory.quantum_instance = None
self.assertEqual(self._vqe_ucc_factory.quantum_instance, None)
with self.subTest("Optimizer"):
self.assertEqual(self._vqe_ucc_factory.optimizer, None)
optimizer = COBYLA()
self._vqe_ucc_factory.optimizer = optimizer
self.assertEqual(self._vqe_ucc_factory.optimizer, optimizer)
with self.subTest("Initial Point"):
self.assertEqual(self._vqe_ucc_factory.initial_point, None)
initial_point = [1, 2, 3]
self._vqe_ucc_factory.initial_point = initial_point
self.assertEqual(self._vqe_ucc_factory.initial_point,
initial_point)
with self.subTest("Expectation"):
self.assertEqual(self._vqe_ucc_factory.expectation, None)
expectation = AerPauliExpectation()
self._vqe_ucc_factory.expectation = expectation
self.assertEqual(self._vqe_ucc_factory.expectation, expectation)
with self.subTest("Include Custom"):
self.assertEqual(self._vqe_ucc_factory.include_custom, False)
self._vqe_ucc_factory.include_custom = True
self.assertEqual(self._vqe_ucc_factory.include_custom, True)
with self.subTest("Ansatz"):
self.assertEqual(self._vqe_ucc_factory.ansatz, None)
ansatz = UCCSD()
self._vqe_ucc_factory.ansatz = ansatz
self.assertTrue(isinstance(self._vqe_ucc_factory.ansatz, UCCSD))
with self.subTest("Initial State"):
self.assertEqual(self._vqe_ucc_factory.initial_state, None)
initial_state = HartreeFock(4, (1, 1), self.converter)
self._vqe_ucc_factory.initial_state = initial_state
self.assertEqual(self._vqe_ucc_factory.initial_state,
initial_state)
def get_solver( # type: ignore[override]
self,
problem: ElectronicStructureProblem,
qubit_converter: QubitConverter,
) -> MinimumEigensolver:
"""Returns a VQE with a UCCSD wavefunction ansatz, based on ``qubit_converter``.
Args:
problem: a class encoding a problem to be solved.
qubit_converter: a class that converts second quantized operator to qubit operator
according to a mapper it is initialized with.
Returns:
A VQE suitable to compute the ground state of the molecule.
"""
driver_result = problem.grouped_property_transformed
particle_number = cast(ParticleNumber,
driver_result.get_property(ParticleNumber))
num_spin_orbitals = particle_number.num_spin_orbitals
num_particles = particle_number.num_alpha, particle_number.num_beta
initial_state = self.initial_state
if initial_state is None:
initial_state = HartreeFock(num_spin_orbitals, num_particles,
qubit_converter)
ansatz = self.ansatz
if ansatz is None:
ansatz = UCCSD()
ansatz.qubit_converter = qubit_converter
ansatz.num_particles = num_particles
ansatz.num_spin_orbitals = num_spin_orbitals
ansatz.initial_state = initial_state
self.minimum_eigensolver.ansatz = ansatz
if isinstance(self.initial_point, InitialPoint):
self.initial_point.ansatz = ansatz
self.initial_point.grouped_property = driver_result
initial_point = self.initial_point.to_numpy_array()
else:
initial_point = self.initial_point
self.minimum_eigensolver.initial_point = initial_point
return self.minimum_eigensolver
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 get_solver(self, problem, qubit_converter):
q_molecule_transformed = cast(
QMolecule, problem.molecule_data_transformed)
num_molecular_orbitals = q_molecule_transformed.num_molecular_orbitals
num_particles = (q_molecule_transformed.num_alpha,
q_molecule_transformed.num_beta)
num_spin_orbitals = 2 * num_molecular_orbitals
initial_state = HartreeFock(num_spin_orbitals, num_particles,
qubit_converter)
ansatz = UCC(qubit_converter=qubit_converter,
num_particles=num_particles,
num_spin_orbitals=num_spin_orbitals,
excitations='d',
initial_state=initial_state)
vqe = VQE(ansatz=ansatz,
quantum_instance=self._quantum_instance,
optimizer=L_BFGS_B())
return vqe
def get_solver(self, transformation):
num_orbitals = transformation.molecule_info['num_orbitals']
num_particles = transformation.molecule_info['num_particles']
qubit_mapping = transformation.qubit_mapping
two_qubit_reduction = transformation.molecule_info[
'two_qubit_reduction']
z2_symmetries = transformation.molecule_info['z2_symmetries']
initial_state = HartreeFock(num_orbitals, num_particles,
qubit_mapping, two_qubit_reduction,
z2_symmetries.sq_list)
var_form = UCCSD(num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=z2_symmetries)
vqe = VQE(var_form=var_form,
quantum_instance=self._quantum_instance,
optimizer=L_BFGS_B())
return vqe
def test_setters_getters(self):
"""Test Getter/Setter. These tests are using the getter/setter from the"""
with self.subTest("Initial Point"):
self.assertTrue(isinstance(self._vqe_ucc_factory.initial_point, HFInitialPoint))
initial_point = [1, 2, 3]
self._vqe_ucc_factory.initial_point = initial_point
self.assertEqual(self._vqe_ucc_factory.initial_point, initial_point)
with self.subTest("Ansatz"):
self.assertEqual(self._vqe_ucc_factory.ansatz, None)
ansatz = UCCSD()
self._vqe_ucc_factory.ansatz = ansatz
self.assertTrue(isinstance(self._vqe_ucc_factory.ansatz, UCCSD))
with self.subTest("Initial State"):
self.assertEqual(self._vqe_ucc_factory.initial_state, None)
initial_state = HartreeFock(4, (1, 1), self.converter)
self._vqe_ucc_factory.initial_state = initial_state
self.assertEqual(self._vqe_ucc_factory.initial_state, initial_state)
def test_qubits_6_py_lih(self):
""" qubits 6 py lih test """
state = HartreeFock(10, (1, 1), 'parity', True, [1, 2])
ref = QuantumCircuit(6)
ref.x([0, 1])
self.assertEqual(state, ref)
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)
def test_qubits_4_bk_h2(self):
""" qubits 4 bk h2 test """
state = HartreeFock(4, (1, 1), QubitConverter(BravyiKitaevMapper()))
ref = QuantumCircuit(4)
ref.x([0, 1, 2])
self.assertEqual(state, ref)
def test_qubits_4_py_h2(self):
""" qubits 4 py h2 test """
state = HartreeFock(4, (1, 1), QubitConverter(ParityMapper()))
ref = QuantumCircuit(4)
ref.x([0, 1])
self.assertEqual(state, ref)
def test_qubits_4_jw_h2(self):
""" qubits 4 jw h2 test """
state = HartreeFock(4, (1, 1), QubitConverter(JordanWignerMapper()))
ref = QuantumCircuit(4)
ref.x([0, 2])
self.assertEqual(state, ref)
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.converters.second_quantization 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)
optimizer = L_BFGS_B()
# setup the mapper and qubit converter
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.converters.second_quantization 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('aer_simulator_statevector')
# setup and run VQE
