def qc_solver(h_qop, num_spin_orbitals, num_particles, map_type, \
qubit_reduction, aux_qops=None):
# backends = Aer.backends()
backends = IBMQ.backends(simulator=False)
print(backends)
# backend = IBMQ.get_backend('ibmq_qasm_simulator')
# backend = IBMQ.get_backend('ibmq_16_melbourne')
# backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
# setup COBYLA optimizer
max_eval = 1000
cobyla = COBYLA(maxiter=max_eval)
# setup hartreeFock state
hf_state = HartreeFock(h_qop.num_qubits, num_spin_orbitals, num_particles,
map_type, qubit_reduction)
# setup UCCSD variational form
var_form = UCCSD(h_qop.num_qubits, depth=1,
num_orbitals=num_spin_orbitals, num_particles=num_particles,
active_occupied=[0], active_unoccupied=[0],
initial_state=hf_state, qubit_mapping=map_type,
two_qubit_reduction=qubit_reduction, num_time_slices=1)
# setup VQE
vqe = VQE(h_qop, var_form, cobyla, operator_mode='matrix', \
aux_operators=aux_qops)
quantum_instance = QuantumInstance(backend=backend, shots=1024,
max_credits=10)
ret = vqe.run(quantum_instance)
print(ret['aux_ops'])
print('The computed ground state energy is: {:.12f}'.format(\
ret['eigvals'][0]))
def test_vqe_2_iqpe(self):
backend = get_aer_backend('qasm_simulator')
num_qbits = self.algo_input.qubit_op.num_qubits
var_form = RYRZ(num_qbits, 3)
optimizer = SPSA(max_trials=10)
# optimizer.set_options(**{'max_trials': 500})
algo = VQE(self.algo_input.qubit_op, var_form, optimizer, 'paulis')
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.log.debug('VQE result: {}.'.format(result))
self.ref_eigenval = -1.85727503
num_time_slices = 50
num_iterations = 11
state_in = VarFormBased(var_form, result['opt_params'])
iqpe = IQPE(self.algo_input.qubit_op,
state_in,
num_time_slices,
num_iterations,
paulis_grouping='random',
expansion_mode='suzuki',
expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend,
shots=100,
pass_manager=PassManager(),
seed=self.random_seed,
seed_mapper=self.random_seed)
result = iqpe.run(quantum_instance)
self.log.debug('top result str label: {}'.format(
result['top_measurement_label']))
self.log.debug('top result in decimal: {}'.format(
result['top_measurement_decimal']))
self.log.debug('stretch: {}'.format(
result['stretch']))
self.log.debug('translation: {}'.format(
result['translation']))
self.log.debug('final eigenvalue from QPE: {}'.format(
result['energy']))
self.log.debug('reference eigenvalue: {}'.format(
self.ref_eigenval))
self.log.debug('ref eigenvalue (transformed): {}'.format(
(self.ref_eigenval + result['translation']) * result['stretch']))
self.log.debug('reference binary str label: {}'.format(
decimal_to_binary((self.ref_eigenval + result['translation']) *
result['stretch'],
max_num_digits=num_iterations + 3,
fractional_part_only=True)))
np.testing.assert_approx_equal(self.ref_eigenval,
result['energy'],
significant=2)
def test_vqe_direct(self, batch_mode):
backend = get_aer_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, 'matrix', batch_mode=batch_mode)
quantum_instance = QuantumInstance(backend)
result = algo.run(quantum_instance)
self.assertAlmostEqual(result['energy'], -1.85727503)
backend = Aer.get_backend('statevector_simulator')
# setup COBYLA optimizer
max_eval = 200
cobyla = COBYLA(maxiter=max_eval)
# setup HartreeFock state
HF_state = HartreeFock(qubitOp.num_qubits, num_spin_orbitals, num_particles,
map_type, qubit_reduction)
# setup UCCSD variational form
var_form = UCCSD(qubitOp.num_qubits,
depth=1,
num_orbitals=num_spin_orbitals,
num_particles=num_particles,
active_occupied=[0],
active_unoccupied=[0, 1],
initial_state=HF_state,
qubit_mapping=map_type,
two_qubit_reduction=qubit_reduction,
num_time_slices=1)
# setup VQE
vqe = VQE(qubitOp, var_form, cobyla, 'matrix')
quantum_instance = QuantumInstance(backend=backend)
results = vqe.run(quantum_instance)
print('The computed ground state energy is: {:.12f}'.format(
results['eigvals'][0]))
print('The total ground state energy is: {:.12f}'.format(
results['eigvals'][0] + energy_shift + nuclear_repulsion_energy))
#print("Parameters: {}".format(results['opt_params']))
seqs=seq_array,
costs=cost_array,
coeffs=coeff_arr,
inserts=insert_vals,
times=np.array(times),
states=np.array(states),
angles=np.array(angle_arr),
energies=np.array(energies))
for s in alignment:
print(s)
# VQE
if method == "VQE":
opt = SPSA(max_trials=100)
trial = RY(Hamilt.num_qubits, depth=10, entanglement='linear')
solver = VQE(Hamilt, trial, opt, "paulis")
simulator = IBMQ.get_backend(backend)
instance = QuantumInstance(backend=simulator, shots=1024)
print("Starting job")
result = solver.run(instance)
print("Job finished?")
state = result["eigvecs"][0]
energy = result["eigvals"][0] + shift
positions = MSA_column.sample_most_likely(state, rev_inds)
for (key, value) in positions.items():
print(key, value)
alignment = MSA_column.get_alignment_string(sequences, inserts, positions)
print("VQE solution: Energy=", energy)
# ======================
# define the initial state
init_state = Zero(num_qubits)
# get a variational ansatz
ansatz = RY(num_qubits, initial_state=init_state)
# operator from hamiltonian
qubit_op = Operator.load_from_dict(pauli_dict)
# get an optimizer
optimizer = COBYLA(maxiter=1000, disp=True)
# form the algorithm
vqe = VQE(qubit_op, ansatz, optimizer)
# get a backend
backend = get_aer_backend("statevector_simulator")
# get a quantum instance
qinstance = QuantumInstance(backend, shots=1024)
# ===================
# do the optimization
# ===================
result = vqe.run(qinstance)
# ================
# show the results
# Build the qubit operator, which is the input to the VQE algorithm in Aqua
ferOp = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
map_type = 'PARITY'
qubitOp = ferOp.mapping(map_type)
qubitOp = qubitOp.two_qubit_reduced_operator(num_particles)
num_qubits = qubitOp.num_qubits
# set the backend for the quantum computation
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
# 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.aqua_extensions.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(qubitOp, var_form, optimizer)
result = algorithm.run(backend)
print(result['energy'])