def test_uccsd_hf_aer_statevector(self):
""" uccsd hf test with Aer statevector """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
backend = Aer.get_backend('statevector_simulator')
algo = VQE(self.qubit_op, self.var_form, self.optimizer)
result = algo.run(QuantumInstance(backend))
result = self.core.process_algorithm_result(result)
self.assertAlmostEqual(result.energy, self.reference_energy, places=6)
def test_vqe_qasm(self):
""" VQE QASm test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
var_form = RY(num_qubits, 3)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
max_evals_grouped=1)
quantum_instance = QuantumInstance(backend,
shots=10000,
optimization_level=0)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=2)
def test_exact_cover_vqe(self):
""" Exact Cover VQE test """
aqua_globals.random_seed = 10598
result = VQE(self.qubit_op,
RYRZ(self.qubit_op.num_qubits, depth=5),
COBYLA(),
max_evals_grouped=2).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
ising_sol = exact_cover.get_solution(x)
oracle = self._brute_force()
self.assertEqual(exact_cover.check_solution_satisfiability(ising_sol, self.list_of_subsets),
oracle)
def cb_default_solver(num_particles, num_orbitals, qubit_mapping,
two_qubit_reduction, z2_symmetries):
""" Default solver """
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)
vqe.quantum_instance = quantum_instance
return vqe
def test_vqe_aer_mode(self):
try:
from qiskit import Aer
except Exception as e:
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(e)))
return
backend = Aer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, 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
def test_clique_vqe(self):
""" VQE Clique test """
aqua_globals.random_seed = 10598
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits, depth=5, entanglement='linear'),
COBYLA(),
max_evals_grouped=2).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
ising_sol = clique.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 1, 1, 1, 1])
oracle = self._brute_force()
self.assertEqual(clique.satisfy_or_not(ising_sol, self.w, self.k), oracle)
def test_stable_set_vqe(self):
""" VQE Stable set test """
result = VQE(
self.qubit_op,
RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='linear'),
L_BFGS_B(maxfun=6000)).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
self.assertAlmostEqual(result['energy'], -29.5)
self.assertAlmostEqual(result['energy'] + self.offset, -25.0)
ising_sol = stable_set.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 0, 1, 1, 1])
self.assertEqual(stable_set.stable_set_value(x, self.w), (3.0, False))
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=aqua_globals.random_seed,
seed_transpiler=aqua_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_end2end_h2(self, name, optimizer, backend, shots):
""" end to end h2 """
del name # unused
if optimizer == 'COBYLA':
optimizer = COBYLA()
optimizer.set_options(maxiter=1000)
elif optimizer == 'SPSA':
optimizer = SPSA(maxiter=2000)
ryrz = TwoLocal(rotation_blocks=['ry', 'rz'], entanglement_blocks='cz')
vqe = VQE(self.qubit_op, ryrz, optimizer, aux_operators=self.aux_ops)
quantum_instance = QuantumInstance(backend, shots=shots)
result = vqe.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real,
self.reference_energy,
places=4)
def test_vertex_cover_vqe(self):
""" Vertex Cover VQE test """
aqua_globals.random_seed = self.seed
result = VQE(self.qubit_op,
RYRZ(self.qubit_op.num_qubits, depth=3),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
sol = vertex_cover.get_graph_solution(x)
oracle = self._brute_force()
self.assertEqual(np.count_nonzero(sol), oracle)
def test_deprecated_algo_result(self):
""" Test processing a deprecated dictionary result from algorithm """
warnings.filterwarnings("ignore", category=DeprecationWarning)
ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full')
vqe = VQE(self.qubit_op, ryrz, COBYLA(), aux_operators=self.aux_ops)
quantum_instance = QuantumInstance(
qiskit.BasicAer.get_backend('statevector_simulator'))
result = vqe.run(quantum_instance)
keys = {'energy', 'energies', 'eigvals', 'eigvecs', 'aux_ops'}
dict_res = {key: result[key] for key in keys}
lines, result = self.core.process_algorithm_result(dict_res)
self.assertAlmostEqual(result['energy'], -1.137306, places=4)
self.assertEqual(len(lines), 19)
self.assertEqual(
lines[8],
' Measured:: Num particles: 2.000, S: 0.000, M: 0.00000')
def vqe_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), include_custom=True)
vqe.quantum_instance = backend
return vqe
def test_vqe_var_forms(self, depth, places):
""" VQE Var Forms test """
aqua_globals.random_seed = self.seed
result = VQE(
self.qubit_op,
RY(self.qubit_op.num_qubits,
depth=depth,
entanglement='sca',
entanglement_gate='crx',
skip_final_ry=True),
L_BFGS_B()).run(
QuantumInstance(BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result['energy'], -1.85727503, places=places)
def test_vqe_qasm(self):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, num_qubits)
optimizer = SPSA(max_trials=300, last_avg=5)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
vqe = VQE(var_form=var_form,
optimizer=optimizer,
max_evals_grouped=1,
quantum_instance=quantum_instance)
output = vqe.compute_minimum_eigenvalue(self.qubit_op)
self.assertAlmostEqual(output.eigenvalue, -1.85727503, places=1)
def test_vqe_direct(self, max_evals_grouped):
backend = BasicAer.get_backend('statevector_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op,
var_form,
optimizer,
'paulis',
max_evals_grouped=max_evals_grouped)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503)
if quantum_instance.has_circuit_caching:
self.assertLess(quantum_instance._circuit_cache.misses, 3)
def test_vqe_optimizers(self, optimizer_cls, places, max_evals_grouped):
""" VQE Optimizers test """
result = VQE(self.qubit_op,
TwoLocal(rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz'),
optimizer_cls(),
max_evals_grouped=max_evals_grouped).run(
QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
self.assertAlmostEqual(result.eigenvalue.real,
-1.85727503,
places=places)
def test_end2end_h2(self, name, optimizer, backend, shots):
""" end to end h2 """
del name # unused
if optimizer == 'COBYLA':
optimizer = COBYLA()
optimizer.set_options(maxiter=1000)
elif optimizer == 'SPSA':
optimizer = SPSA(max_trials=2000)
ryrz = RYRZ(self.qubit_op.num_qubits, depth=3, entanglement='full')
vqe = VQE(self.qubit_op, ryrz, optimizer, aux_operators=self.aux_ops)
quantum_instance = QuantumInstance(backend, shots=shots)
results = vqe.run(quantum_instance)
self.assertAlmostEqual(results['energy'],
self.reference_energy,
places=4)
def test_partition_vqe(self):
""" Partition VQE test """
aqua_globals.random_seed = 100
result = VQE(self.qubit_op,
RY(self.qubit_op.num_qubits,
depth=5,
entanglement='linear'),
SPSA(max_trials=200),
max_evals_grouped=2).run(
QuantumInstance(
BasicAer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed))
x = sample_most_likely(result['eigvecs'][0])
self.assertNotEqual(x[0], x[1])
self.assertNotEqual(x[2], x[1]) # hardcoded oracle
def test_uccsd_hf_aer_statevector(self):
""" uccsd hf test with Aer statevector """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
backend = Aer.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 test_vqe_qasm(self, var_form_type):
""" VQE QASM test """
backend = BasicAer.get_backend('qasm_simulator')
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, depth=3)
if var_form_type is QuantumCircuit:
params = ParameterVector('θ', var_form.num_parameters)
var_form = var_form.construct_circuit(params)
optimizer = SPSA(max_trials=300, last_avg=5)
algo = VQE(self.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=10000,
seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=2)
def test_uvcc_vscf(self):
""" uvcc vscf test """
co2_2modes_2modals_2body = [
[[[[0, 0, 0]], 320.8467332810141], [[[0, 1, 1]],
1760.878530705873],
[[[1, 0, 0]], 342.8218290247543], [[[1, 1, 1]],
1032.396323618631]],
[[[[0, 0, 0], [1, 0, 0]], -57.34003649795117],
[[[0, 0, 1], [1, 0, 0]], -56.33205925807966],
[[[0, 1, 0], [1, 0, 0]], -56.33205925807966],
[[[0, 1, 1], [1, 0, 0]], -60.13032761856809],
[[[0, 0, 0], [1, 0, 1]], -65.09576309934431],
[[[0, 0, 1], [1, 0, 1]], -62.2363839133389],
[[[0, 1, 0], [1, 0, 1]], -62.2363839133389],
[[[0, 1, 1], [1, 0, 1]], -121.5533969109279],
[[[0, 0, 0], [1, 1, 0]], -65.09576309934431],
[[[0, 0, 1], [1, 1, 0]], -62.2363839133389],
[[[0, 1, 0], [1, 1, 0]], -62.2363839133389],
[[[0, 1, 1], [1, 1, 0]], -121.5533969109279],
[[[0, 0, 0], [1, 1, 1]], -170.744837386338],
[[[0, 0, 1], [1, 1, 1]], -167.7433236025723],
[[[0, 1, 0], [1, 1, 1]], -167.7433236025723],
[[[0, 1, 1], [1, 1, 1]], -179.0536532281924]]
]
basis = [2, 2]
bosonic_op = BosonicOperator(co2_2modes_2modals_2body, basis)
qubit_op = bosonic_op.mapping('direct', threshold=1e-5)
init_state = VSCF(basis)
num_qubits = sum(basis)
uvcc_varform = UVCC(num_qubits,
basis, [0, 1],
initial_state=init_state)
backend = BasicAer.get_backend('statevector_simulator')
optimizer = COBYLA(maxiter=1000)
algo = VQE(qubit_op, uvcc_varform, optimizer)
vqe_result = algo.run(backend)
energy = vqe_result['optimal_value']
self.assertAlmostEqual(energy, self.reference_energy, places=4)
def test_measurement_error_mitigation_with_vqe(self):
""" measurement error mitigation test with vqe """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
from qiskit.providers.aer import noise
except ImportError as ex: # pylint: disable=broad-except
self.skipTest(
"Aer doesn't appear to be installed. Error: '{}'".format(
str(ex)))
return
aqua_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1],
[0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
h2_hamiltonian = -1.052373245772859 * (I ^ I) \
+ 0.39793742484318045 * (I ^ Z) \
- 0.39793742484318045 * (Z ^ I) \
- 0.01128010425623538 * (Z ^ Z) \
+ 0.18093119978423156 * (X ^ X)
optimizer = SPSA(maxiter=200)
var_form = EfficientSU2(2, reps=1)
vqe = VQE(
var_form=var_form,
operator=h2_hamiltonian,
quantum_instance=quantum_instance,
optimizer=optimizer,
)
result = vqe.compute_minimum_eigenvalue()
self.assertGreater(quantum_instance.time_taken, 0.)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, places=2)
def run(self, instance, verbose=False):
for i, d in enumerate(self.distances):
print("Simulation step", i, "simulating molecule: ", self.molecule.format(d))
if verbose:
print("PySCFDriver")
driver = PySCFDriver(self.molecule.format(d), basis="sto3g")
if verbose:
print("driver.run")
qmolecule = driver.run()
if verbose:
print("Hamiltonian")
operator = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=self.two_qubit_reduction,
freeze_core=self.freeze_core,
orbital_reduction=self.orbital_reduction)
if verbose:
print("Hamiltonian.run")
qubit_op, aux_ops = operator.run(qmolecule)
if verbose:
print("SLSQP")
optimizer = SLSQP(maxiter=100)
if verbose:
print("HartreeFock")
initial_state = HartreeFock(operator.molecule_info["num_orbitals"],
operator.molecule_info["num_particles"],
"parity",
two_qubit_reduction=self.two_qubit_reduction)
if verbose:
print("UCCSD")
var_form = UCCSD(num_orbitals=operator.molecule_info["num_orbitals"],
num_particles=operator.molecule_info["num_particles"],
initial_state=initial_state,
qubit_mapping="parity",
two_qubit_reduction=self.two_qubit_reduction)
if verbose:
print("VQE")
algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
if verbose:
print("VQE.run")
vqe_result = algo.run(instance)
if verbose:
print("Hamiltonian.process_algorithm_result")
vqe_result_processed = operator.process_algorithm_result(vqe_result)
self.vqe_energies.append(vqe_result_processed.energy)
self.hf_energies.append(vqe_result_processed.hartree_fock_energy)
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.total_energies[0], self.reference_energy_UCCSD, places=6)
def setUp(self):
super().setUp()
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.735',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
self.npme = NumPyMinimumEigensolver()
self.vqe = VQE(var_form=TwoLocal(rotation_blocks='ry', entanglement_blocks='cz'))
self.vqe.set_backend(BasicAer.get_backend('statevector_simulator'))
self.reference_energy = -1.137306
def run_IBMQ(self):
""" Use VQE on a real device to determine ground energy eigenvectors of the
hamiltonian
"""
self.operator, var_form, opt = self.generate_VQE_args()
nqbits = self.operator.num_qubits
IBMQ.load_accounts()
backend = self.find_least_busy(nqbits)
quantum_instance = QuantumInstance(backend=backend)
vqe = VQE(self.operator, var_form, opt)
self.result = vqe.run(quantum_instance)
solution = self.extract_solution(self.result, False)
return solution
def test_vqe_2_iqpe(self):
""" vqe to iqpe test """
backend = BasicAer.get_backend('qasm_simulator')
num_qbits = self.qubit_op.num_qubits
wavefunction = TwoLocal(num_qbits, ['ry', 'rz'], 'cz', reps=3, insert_barriers=True)
optimizer = SPSA(max_trials=10)
algo = VQE(self.qubit_op, wavefunction, optimizer)
quantum_instance = QuantumInstance(backend, seed_simulator=self.seed,
seed_transpiler=self.seed)
result = algo.run(quantum_instance)
self.log.debug('VQE result: %s.', result)
ref_eigenval = -1.85727503 # Known reference value
num_time_slices = 1
num_iterations = 6
param_dict = result.optimal_parameters
state_in = VarFormBased(wavefunction, param_dict)
iqpe = IQPE(self.qubit_op, state_in, num_time_slices, num_iterations,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(
backend, shots=100, seed_transpiler=self.seed, seed_simulator=self.seed
)
result = iqpe.run(quantum_instance)
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 eigenvalue from QPE: %s', result.eigenvalue)
self.log.debug('reference eigenvalue: %s', ref_eigenval)
self.log.debug('ref eigenvalue (transformed): %s',
(ref_eigenval + result.translation) * result.stretch)
self.log.debug('reference binary str label: %s', decimal_to_binary(
(ref_eigenval.real + result.translation) * result.stretch,
max_num_digits=num_iterations + 3,
fractional_part_only=True
))
self.assertAlmostEqual(result.eigenvalue.real, ref_eigenval.real, delta=1e-2)
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_vqe_qasm_snapshot_mode(self):
""" VQE Aer qasm_simulator snapshot mode test """
try:
# pylint: disable=import-outside-toplevel
from qiskit import Aer
except Exception as ex: # pylint: disable=broad-except
self.skipTest("Aer doesn't appear to be installed. Error: '{}'".format(str(ex)))
return
backend = Aer.get_backend('qasm_simulator')
num_qubits = self.algo_input.qubit_op.num_qubits
init_state = Zero(num_qubits)
var_form = RY(num_qubits, 3, initial_state=init_state)
optimizer = L_BFGS_B()
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, max_evals_grouped=1)
quantum_instance = QuantumInstance(backend, shots=1)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503, places=6)