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 _compute_gradients(self, excitation_pool, theta, delta, var_form,
operator, optimizer):
"""
Computes the gradients for all available excitation operators.
Args:
excitation_pool (list): pool of excitation operators
theta (list): list of (up to now) optimal parameters
delta (float): finite difference step size (for gradient computation)
var_form (VariationalForm): current variational form
operator (LegacyBaseOperator): system Hamiltonian
optimizer (Optimizer): classical optimizer algorithm
Returns:
list: List of pairs consisting of gradient and excitation operator.
"""
res = []
# compute gradients for all excitation in operator pool
for exc in excitation_pool:
# push next excitation to variational form
var_form.push_hopping_operator(exc)
# construct auxiliary VQE instance
vqe = VQE(operator, var_form, optimizer)
vqe.quantum_instance = self.quantum_instance
# evaluate energies
parameter_sets = theta + [-delta] + theta + [delta]
energy_results = vqe._energy_evaluation(np.asarray(parameter_sets))
# compute gradient
gradient = (energy_results[0] - energy_results[1]) / (2 * delta)
res.append((np.abs(gradient), exc))
# pop excitation from variational form
var_form.pop_hopping_operator()
return res
def test_reuse(self):
"""Test re-using a VQE algorithm instance."""
vqe = VQE()
with self.subTest(msg='assert running empty raises AquaError'):
with self.assertRaises(AquaError):
_ = vqe.run()
var_form = TwoLocal(rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz')
vqe.var_form = var_form
with self.subTest(msg='assert missing operator raises AquaError'):
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.operator = self.h2_op
with self.subTest(msg='assert missing backend raises AquaError'):
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.quantum_instance = self.statevector_simulator
with self.subTest(msg='assert VQE works once all info is available'):
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real,
self.h2_energy,
places=5)
operator = PrimitiveOp(
np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 2, 0], [0, 0, 0,
3]]))
with self.subTest(msg='assert minimum eigensolver interface works'):
result = vqe.compute_minimum_eigenvalue(operator)
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
def test_vqe_reuse(self):
""" Test vqe reuse """
vqe = VQE()
with self.assertRaises(AquaError):
_ = vqe.run()
var_form = TwoLocal(rotation_blocks=['ry', 'rz'],
entanglement_blocks='cz')
vqe.var_form = var_form
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.operator = self.qubit_op
with self.assertRaises(AquaError):
_ = vqe.run()
qinst = QuantumInstance(BasicAer.get_backend('statevector_simulator'))
vqe.quantum_instance = qinst
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
operator = PrimitiveOp(
np.array([[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, 2, 0], [0, 0, 0,
3]]))
vqe.operator = operator
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
def test_vqe_reuse(self):
""" Test vqe reuse """
vqe = VQE()
with self.assertRaises(AquaError):
_ = vqe.run()
num_qubits = self.qubit_op.num_qubits
var_form = RY(num_qubits, depth=3)
vqe.var_form = var_form
with self.assertRaises(AquaError):
_ = vqe.run()
vqe.operator = self.qubit_op
with self.assertRaises(AquaError):
_ = vqe.run()
qinst = QuantumInstance(BasicAer.get_backend('statevector_simulator'))
vqe.quantum_instance = qinst
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.85727503, places=5)
operator = MatrixOperator(np.array([[1, 0, 0, 0],
[0, -1, 0, 0],
[0, 0, 2, 0],
[0, 0, 0, 3]]))
vqe.operator = operator
result = vqe.run()
self.assertAlmostEqual(result.eigenvalue.real, -1.0, places=5)
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 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 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 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 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)
var_form = EfficientSU2(num_qubits=no_qubits, entanglement="linear")
vqe = VQE(var_form=var_form,
optimizer=SPSA(maxiter=500),
include_custom=True)
vqe.quantum_instance = quantum_instance
return vqe
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,
include_custom=True,
optimizer=SLSQP(maxiter=5000),
max_evals_grouped=256)
vqe.quantum_instance = Aer.get_backend('qasm_simulator')
vqe.quantum_instance.backend_options['backend_options'] = {
'max_parallel_experiments': threads,
'method': method
}
return vqe
