def test_qubits_2_py_h2_cct(self):
""" qubits 2 py h2 cct test """
hrfo = HartreeFock(4, [1, 1], 'parity', True)
cct = hrfo.construct_circuit('circuit')
self.assertEqual(
cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[2];\n'
'u(pi,0,pi) q[0];\n')
def test_qubits_6_py_lih_cct(self):
""" qubits 6 py lih cct test """
hrfo = HartreeFock(6, 10, [1, 1], 'parity', True, [1, 2])
cct = hrfo.construct_circuit('circuit')
self.assertEqual(cct.qasm(), 'OPENQASM 2.0;\ninclude "qelib1.inc";\nqreg q[6];\n'
'u3(3.14159265358979,0.0,3.14159265358979) q[0];\n'
'u3(3.14159265358979,0.0,3.14159265358979) q[1];\n')
def test_hf_value(self, mapping):
""" hf value test """
try:
driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0 1.6',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
qmolecule = driver.run()
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=mapping,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(qmolecule)
qubit_op = op_converter.to_matrix_operator(qubit_op)
hrfo = HartreeFock(core.molecule_info['num_orbitals'],
core.molecule_info['num_particles'], mapping.value,
False)
qc = hrfo.construct_circuit('vector')
hf_energy = qubit_op.evaluate_with_statevector(
qc)[0].real + core._nuclear_repulsion_energy
self.assertAlmostEqual(qmolecule.hf_energy, hf_energy, places=8)
def test_hf_value(self, mapping):
""" hf value test """
try:
driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0 1.6',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
fermionic_transformation = FermionicTransformation(transformation=TransformationType.FULL,
qubit_mapping=mapping,
two_qubit_reduction=False,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = fermionic_transformation.transform(driver)
hrfo = HartreeFock(fermionic_transformation.molecule_info['num_orbitals'],
fermionic_transformation.molecule_info['num_particles'],
mapping.value,
two_qubit_reduction=False)
qc = hrfo.construct_circuit('vector')
exp = ~StateFn(qubit_op) @ StateFn(qc)
hf_energy = exp.eval().real \
+ fermionic_transformation._nuclear_repulsion_energy
self.assertAlmostEqual(fermionic_transformation._hf_energy, hf_energy, places=6)
def test_qubits_4_py_h2(self):
""" qubits 4 py h2 test """
hrfo = HartreeFock(4, [1, 1], 'parity', False)
cct = hrfo.construct_circuit('vector')
np.testing.assert_array_equal(cct, [
0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
])
def test_qubits_4_jw_h2(self):
""" qubits 4 jw h2 test """
hrfo = HartreeFock(4, [1, 1], 'jordan_wigner', False)
cct = hrfo.construct_circuit('vector')
np.testing.assert_array_equal(cct, [
0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
])
def test_qubits_4_bk_h2(self):
""" qubits 4 bk h2 test """
hrfo = HartreeFock(4, [1, 1], 'bravyi_kitaev', False)
cct = hrfo.construct_circuit('vector')
np.testing.assert_array_equal(cct, [
0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0,
0.0, 0.0, 0.0
])
def vqe_create_solver(num_particles, num_orbitals, qubit_mapping,
two_qubit_reduction, z2_symmetries,
initial_point = system.opt_amplitudes,
noise = noise):
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)
if noise:
var_form = EfficientSU2(num_qubits = no_qubits, entanglement="linear")
else:
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, optimizer=SLSQP(maxiter=500),
include_custom=True, initial_point = initial_point)
vqe.quantum_instance = backend
return vqe
def test_excitation_preserving(self):
"""Test the excitation preserving wavefunction on a chemistry example."""
driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5'))
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False)
qubit_op, _ = operator.run(qmolecule)
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
wavefunction = ExcitationPreserving(qubit_op.num_qubits,
initial_state=initial_state)
algo = VQE(qubit_op, wavefunction, optimizer)
result = algo.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
result = operator.process_algorithm_result(result)
self.assertAlmostEqual(result.energy, self.reference_energy, places=6)
def test_swaprz(self):
""" SwapRZ variational form test """
driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5'))
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False)
qubit_op, _ = operator.run(qmolecule)
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
qubit_op.num_qubits,
operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
var_form = SwapRZ(qubit_op.num_qubits, initial_state=initial_state)
algo = VQE(qubit_op, var_form, optimizer)
result = algo.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
_, result = operator.process_algorithm_result(result)
self.assertAlmostEqual(result['energy'],
self.reference_energy,
places=6)
def test_tapered_op(self):
""" tapered op test """
tapered_ops = self.z2_symmetries.taper(self.qubit_op)
smallest_idx = 0 # Prior knowledge of which tapered_op has ground state
the_tapered_op = tapered_ops[smallest_idx]
optimizer = SLSQP(maxiter=1000)
init_state = HartreeFock(num_qubits=the_tapered_op.num_qubits,
num_orbitals=self.core._molecule_info['num_orbitals'],
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_particles=self.core._molecule_info['num_particles'],
sq_list=the_tapered_op.z2_symmetries.sq_list)
var_form = UCCSD(num_qubits=the_tapered_op.num_qubits, depth=1,
num_orbitals=self.core._molecule_info['num_orbitals'],
num_particles=self.core._molecule_info['num_particles'],
active_occupied=None, active_unoccupied=None,
initial_state=init_state,
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=the_tapered_op.z2_symmetries)
algo = VQE(the_tapered_op, var_form, optimizer)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend)
algo_result = algo.run(quantum_instance)
_, result = self.core.process_algorithm_result(algo_result)
self.assertAlmostEqual(result['energy'], self.reference_energy, places=6)
def test_uccsd_hf_qpUCCD(self):
""" paired uccd test """
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(self.qubit_op.num_qubits,
self.core.molecule_info['num_orbitals'],
self.core.molecule_info['num_particles'],
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction)
var_form = UCCSD(num_qubits=self.qubit_op.num_qubits, depth=1,
num_orbitals=self.core._molecule_info['num_orbitals'],
num_particles=self.core._molecule_info['num_particles'],
active_occupied=None, active_unoccupied=None,
initial_state=initial_state,
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_time_slices=1,
shallow_circuit_concat=False,
method_doubles='pucc',
excitation_type='d'
)
algo = VQE(self.qubit_op, var_form, optimizer)
result = algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
_, result = self.core.process_algorithm_result(result)
self.assertAlmostEqual(result['energy'], self.reference_energy_pUCCD, places=6)
def setUp(self):
super().setUp()
self.reference_energy = -1.1373060356951838
self.seed = 700
aqua_globals.random_seed = self.seed
self.driver = HDF5Driver(
self.get_resource_path('test_driver_hdf5.hdf5'))
fermionic_transformation = FermionicTransformation(
qubit_mapping=QubitMappingType.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 generate_uccsd(molecule_data):
molecule, qubitOp, map_type, num_particles, num_spin_orbitals = load_qubitop_for_molecule(molecule_data)
nuclear_repulsion_energy = molecule.nuclear_repulsion_energy
print("# of electrons: {}".format(num_particles))
print("# of spin orbitals: {}".format(num_spin_orbitals))
qubit_reduction = False
HF_state = HartreeFock(num_spin_orbitals, num_particles, map_type, qubit_reduction)
uccsd_ansatz = UCCSD(reps=1,
num_orbitals=num_spin_orbitals, num_particles=num_particles,
initial_state=HF_state, qubit_mapping=map_type,
two_qubit_reduction=qubit_reduction)
circ = uccsd_ansatz.construct_circuit([0.4242] *
uccsd_ansatz.num_parameters)
circ.measure_all()
circ_transpiled = processor.transpile(circ)
q_layer = qiskit2tq(circ_transpiled)
for name, param in q_layer.named_parameters():
if not (param % (np.pi / 2)).detach().cpu().numpy().any():
param.requires_grad = False
#randlist = np.random.rand(uccsd_ansatz.num_parameters) # ansatz parameters
#uccsd_ansatz_circuit = uccsd_ansatz.construct_circuit(randlist)
return q_layer
def test_vqe_auto_symmetry_freeze_core(self):
""" Auto symmetry reduction, with freeze core using VQE """
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True,
orbital_reduction=None,
z2symmetry_reduction='auto')
qubit_op, aux_ops = core.run(self.qmolecule)
self.assertEqual(qubit_op.num_qubits, 6)
num_orbitals = core.molecule_info[core.INFO_NUM_ORBITALS]
num_particles = core.molecule_info[core.INFO_NUM_PARTICLES]
qubit_mapping = 'jordan_wigner'
two_qubit_reduction = core.molecule_info[core.INFO_TWO_QUBIT_REDUCTION]
z2_symmetries = core.molecule_info[core.INFO_Z2SYMMETRIES]
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(qubit_op, var_form=var_form, optimizer=SLSQP(maxiter=500), aux_operators=aux_ops)
vqe.quantum_instance = BasicAer.get_backend('statevector_simulator')
result = core.process_algorithm_result(vqe.compute_minimum_eigenvalue())
self._validate_result(result)
self.assertEqual(core.molecule_info[core.INFO_Z2SYMMETRIES].tapering_values, [-1, 1, 1, -1])
def test_swaprz(self, mode):
""" SwapRZ variational form test """
driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5'))
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False)
qubit_op, _ = operator.run(qmolecule)
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
if mode == 'wrapped':
warnings.filterwarnings('ignore', category=DeprecationWarning)
wavefunction = SwapRZ(qubit_op.num_qubits,
initial_state=initial_state)
else:
wavefunction = ExcitationPreserving(qubit_op.num_qubits,
initial_state=initial_state)
algo = VQE(qubit_op, wavefunction, optimizer)
if mode == 'wrapped':
warnings.filterwarnings('always', category=DeprecationWarning)
result = algo.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
result = operator.process_algorithm_result(result)
self.assertAlmostEqual(result.energy, self.reference_energy, places=6)
def test_h2_two_qubits_statevector(self):
"""Test H2 with parity mapping and statevector backend."""
two_qubit_reduction = True
qubit_mapping = 'parity'
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(self.molecule)
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
initial_state = HartreeFock(qubit_op.num_qubits, num_orbitals=num_orbitals,
num_particles=num_particles, qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction)
var_form = UCCSD(num_qubits=qubit_op.num_qubits, depth=1, num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction)
optimizer = COBYLA(maxiter=1000, tol=1e-8)
eom_vqe = QEomVQE(qubit_op, var_form, optimizer, num_orbitals=num_orbitals,
num_particles=num_particles, qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend)
result = eom_vqe.run(quantum_instance)
np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=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'))
fermionic_transformation = FermionicTransformation(
qubit_mapping=QubitMappingType.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,
initial_state=initial_state)
solver = VQE(var_form=wavefunction,
optimizer=optimizer,
quantum_instance=QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
gsc = GroundStateEigensolver(fermionic_transformation, solver)
result = gsc.solve(driver)
self.assertAlmostEqual(result.energy, self.reference_energy, places=4)
def test_qubits_10_bk_lih_bitstr(self):
""" qubits 10 bk lih bitstr test """
hrfo = HartreeFock(10, [1, 1], 'bravyi_kitaev', False)
bitstr = hrfo.bitstr
np.testing.assert_array_equal(
bitstr,
[False, False, False, False, True, False, True, False, True, True])
def setUp(self):
super().setUp()
# np.random.seed(50)
self.seed = 50
aqua_globals.random_seed = self.seed
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
return
molecule = 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 = Z2Symmetries.two_qubit_reduction(
to_weighted_pauli_operator(qubit_op), self.num_particles)
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_qUCCSD(self):
""" uccsd tapering test using all double excitations """
# optimizer
optimizer = SLSQP(maxiter=100)
# initial state
init_state = HartreeFock(num_qubits=self.the_tapered_op.num_qubits,
num_orbitals=self.core._molecule_info['num_orbitals'],
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_particles=self.core._molecule_info['num_particles'],
sq_list=self.the_tapered_op.z2_symmetries.sq_list)
var_form = UCCSD(num_qubits=self.the_tapered_op.num_qubits, depth=1,
num_orbitals=self.core._molecule_info['num_orbitals'],
num_particles=self.core._molecule_info['num_particles'],
active_occupied=None, active_unoccupied=None,
initial_state=init_state,
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=self.the_tapered_op.z2_symmetries,
shallow_circuit_concat=False,
method_doubles='ucc',
excitation_type='sd',
skip_commute_test=True)
algo = VQE(self.the_tapered_op, var_form, optimizer)
result = algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
_, result = self.core.process_algorithm_result(result)
self.assertAlmostEqual(result['energy'], self.reference_energy_UCCSD, places=6)
def test_uccsd_hf(self):
""" uccsd hf test """
driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5'))
qmolecule = driver.run()
core = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True)
qubit_op, _ = core.run(qmolecule)
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
core.molecule_info['num_orbitals'],
core.molecule_info['num_particles'],
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=core._two_qubit_reduction)
var_form = UCCSD(num_orbitals=core.molecule_info['num_orbitals'],
num_particles=core.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=core._two_qubit_reduction)
algo = VQE(qubit_op, var_form, optimizer)
result = algo.run(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
result = core.process_algorithm_result(result)
self.assertAlmostEqual(result.energy, self.reference_energy, places=6)
def setUp(self):
super().setUp()
self.reference_energy = -1.1373060356951838
self.seed = 700
aqua_globals.random_seed = self.seed
driver = HDF5Driver(self.get_resource_path('test_driver_hdf5.hdf5'))
qmolecule = driver.run()
core = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True)
self.qubit_op, _ = core.run(qmolecule)
self.core = core
self.optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(
core.molecule_info['num_orbitals'],
core.molecule_info['num_particles'],
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=core._two_qubit_reduction)
self.var_form = UCCSD(
num_orbitals=core.molecule_info['num_orbitals'],
num_particles=core.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=core._qubit_mapping,
two_qubit_reduction=core._two_qubit_reduction)
def test_qpe(self, distance):
""" qpe test """
self.log.debug('Testing End-to-End with QPE on '
'H2 with inter-atomic distance %s.', distance)
try:
driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 {}'.format(distance),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
molecule = driver.run()
qubit_mapping = 'parity'
fer_op = FermionicOperator(
h1=molecule.one_body_integrals, h2=molecule.two_body_integrals)
qubit_op = fer_op.mapping(map_type=qubit_mapping, threshold=1e-10)
qubit_op = Z2Symmetries.two_qubit_reduction(qubit_op, 2)
exact_eigensolver = ExactEigensolver(qubit_op, k=1)
results = exact_eigensolver.run()
reference_energy = results['energy']
self.log.debug('The exact ground state energy is: %s', results['energy'])
num_particles = molecule.num_alpha + molecule.num_beta
two_qubit_reduction = True
num_orbitals = qubit_op.num_qubits + \
(2 if two_qubit_reduction else 0)
num_time_slices = 1
n_ancillae = 6
state_in = HartreeFock(qubit_op.num_qubits, num_orbitals,
num_particles, qubit_mapping, two_qubit_reduction)
iqft = Standard(n_ancillae)
qpe = QPE(qubit_op, state_in, iqft, num_time_slices, n_ancillae,
expansion_mode='suzuki',
expansion_order=2, shallow_circuit_concat=True)
backend = qiskit.BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=100)
result = qpe.run(quantum_instance)
self.log.debug('eigvals: %s', result['eigvals'])
self.log.debug('top result str label: %s', result['top_measurement_label'])
self.log.debug('top result in decimal: %s', result['top_measurement_decimal'])
self.log.debug('stretch: %s', result['stretch'])
self.log.debug('translation: %s', result['translation'])
self.log.debug('final energy from QPE: %s', result['energy'])
self.log.debug('reference energy: %s', reference_energy)
self.log.debug('ref energy (transformed): %s',
(reference_energy + result['translation']) * result['stretch'])
self.log.debug('ref binary str label: %s',
decimal_to_binary(
(reference_energy + result['translation']) * result['stretch'],
max_num_digits=n_ancillae + 3, fractional_part_only=True))
np.testing.assert_approx_equal(result['energy'], reference_energy, significant=2)
def test_uccsd_hf_excitations(self):
""" uccsd tapering test using all double excitations """
# initial state
init_state = HartreeFock(
num_qubits=self.the_tapered_op.num_qubits,
num_orbitals=self.core._molecule_info['num_orbitals'],
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_particles=self.core._molecule_info['num_particles'],
sq_list=self.the_tapered_op.z2_symmetries.sq_list)
# check singlet excitations
var_form = UCCSD(
num_qubits=self.the_tapered_op.num_qubits,
depth=1,
num_orbitals=self.core._molecule_info['num_orbitals'],
num_particles=self.core._molecule_info['num_particles'],
active_occupied=None,
active_unoccupied=None,
initial_state=init_state,
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=self.the_tapered_op.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_qubits=self.the_tapered_op.num_qubits,
depth=1,
num_orbitals=self.core._molecule_info['num_orbitals'],
num_particles=self.core._molecule_info['num_particles'],
active_occupied=None,
active_unoccupied=None,
initial_state=init_state,
qubit_mapping=self.core._qubit_mapping,
two_qubit_reduction=self.core._two_qubit_reduction,
num_time_slices=1,
z2_symmetries=self.the_tapered_op.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 test_uccsd_hf_qUCCSD(self):
""" uccsd tapering test using all double excitations """
fermionic_transformation = FermionicTransformation(
transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.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.energy,
self.reference_energy_UCCSD,
places=6)
def cb_create_solver(num_particles, num_orbitals,
qubit_mapping, two_qubit_reduction, z2_symmetries):
state_in = HartreeFock(num_orbitals, num_particles, qubit_mapping,
two_qubit_reduction, z2_symmetries.sq_list)
iqpe = IQPE(None, state_in, num_time_slices=1, num_iterations=6,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
iqpe.quantum_instance = QuantumInstance(BasicAer.get_backend('qasm_simulator'),
shots=100)
return iqpe
def _initial_state_set(num_spinorb, num_part, qubitop_map, qubitop_z2red):
initial_state = HartreeFock(
num_orbitals=num_spinorb,
num_particles=num_part,
qubit_mapping=qubitop_map,
two_qubit_reduction=False #qubitop_z2red
)
return initial_state
def test_readme_sample(self):
""" readme sample test """
# pylint: disable=import-outside-toplevel
# --- Exact copy of sample code ----------------------------------------
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.aqua.operators import Z2Symmetries
# 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 in Aqua
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 = Z2Symmetries.two_qubit_reduction(qubit_op, num_particles)
num_qubits = qubit_op.num_qubits
# setup a classical optimizer for VQE
from qiskit.aqua.components.optimizers import L_BFGS_B
optimizer = L_BFGS_B()
# setup the initial state for the variational form
from qiskit.chemistry.components.initial_states import HartreeFock
init_state = HartreeFock(num_qubits, num_spin_orbitals, num_particles)
# setup the variational form for VQE
from qiskit.aqua.components.variational_forms import RYRZ
var_form = RYRZ(num_qubits, initial_state=init_state)
# setup and run VQE
from qiskit.aqua.algorithms import VQE
algorithm = VQE(qubit_op, var_form, optimizer)
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
result = algorithm.run(backend)
print(result['energy'])
# ----------------------------------------------------------------------
self.assertAlmostEqual(result['energy'], -1.8572750301938803, places=6)
def cb_create_solver(num_particles, num_orbitals,
qubit_mapping, two_qubit_reduction, 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, optimizer=SLSQP(maxiter=500))
vqe.quantum_instance = BasicAer.get_backend('statevector_simulator')
return vqe
