def test_default(self):
""" Default execution """
solver = VQEUCCSDFactory(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = AdaptVQE(self.transformation, solver)
res = calc.solve(self.driver)
self.assertAlmostEqual(res.electronic_energy, self.expected, places=6)
def test_print_result(self):
"""Regression test against issues with printing results."""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(self.problem)
with contextlib.redirect_stdout(io.StringIO()) as out:
print(res)
# do NOT change the below! Lines have been truncated as to not force exact numerical matches
expected = """\
=== GROUND STATE ENERGY ===
* Electronic ground state energy (Hartree): -1.857
- computed part: -1.857
~ Nuclear repulsion energy (Hartree): 0.719
> Total ground state energy (Hartree): -1.137
=== MEASURED OBSERVABLES ===
0: # Particles: 2.000 S: 0.000 S^2: 0.000 M: 0.000
=== DIPOLE MOMENTS ===
~ Nuclear dipole moment (a.u.): [0.0 0.0 1.38
0:
* Electronic dipole moment (a.u.): [0.0 0.0 1.38
- computed part: [0.0 0.0 1.38
> Dipole moment (a.u.): [0.0 0.0 0.0] Total: 0.
(debye): [0.0 0.0 0.0] Total: 0.
"""
for truth, expected in zip(out.getvalue().split("\n"),
expected.split("\n")):
assert truth.strip().startswith(expected.strip())
def run(self, qobj):
"""Main job in simulator"""
if HAS_AER:
if qobj.type == 'PULSE':
from qiskit.providers.aer.pulse import PulseSystemModel
system_model = PulseSystemModel.from_backend(self)
sim = Aer.get_backend('pulse_simulator')
job = sim.run(qobj, system_model)
else:
sim = Aer.get_backend('qasm_simulator')
if self.properties():
from qiskit.providers.aer.noise import NoiseModel
noise_model = NoiseModel.from_backend(self, warnings=False)
job = sim.run(qobj, noise_model=noise_model)
else:
job = sim.run(qobj)
else:
if qobj.type == 'PULSE':
raise QiskitError("Unable to run pulse schedules without "
"qiskit-aer installed")
warnings.warn("Aer not found using BasicAer and no noise",
RuntimeWarning)
sim = BasicAer.get_backend('qasm_simulator')
job = sim.run(qobj)
return job
def test_custom_minimum_eigensolver(self):
""" Test custom MES """
class CustomFactory(VQEUCCFactory):
"""A custom MESFactory"""
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
solver = CustomFactory(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(self.problem)
self.assertAlmostEqual(res.electronic_energies[0],
self.expected,
places=6)
def setUp(self):
super().setUp()
self.driver1 = HDF5Driver(
hdf5_input=self.get_resource_path('test_oovqe_h4.hdf5'))
self.driver2 = HDF5Driver(
hdf5_input=self.get_resource_path('test_oovqe_lih.hdf5'))
self.driver3 = HDF5Driver(
hdf5_input=self.get_resource_path('test_oovqe_h4_uhf.hdf5'))
self.energy1_rotation = -3.0104
self.energy1 = -2.77 # energy of the VQE with pUCCD ansatz and LBFGSB optimizer
self.energy2 = -7.70
self.energy3 = -2.50
self.initial_point1 = [
0.039374, -0.47225463, -0.61891996, 0.02598386, 0.79045546,
-0.04134567, 0.04944946, -0.02971617, -0.00374005, 0.77542149
]
self.seed = 50
self.optimizer = COBYLA(maxiter=1)
self.transformation1 = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False)
self.transformation2 = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=True)
self.quantum_instance = QuantumInstance(
BasicAer.get_backend('statevector_simulator'),
shots=1,
seed_simulator=self.seed,
seed_transpiler=self.seed)
def test_custom_minimum_eigensolver(self):
""" Test custom MES """
# Note: the VQEUCCSDFactory actually allows to specify an optimizer through its constructor.
# Thus, this example is quite far fetched but for a proof-of-principle test it still works.
class CustomFactory(VQEUCCSDFactory):
"""A custom MESFactory"""
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
solver = CustomFactory(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = AdaptVQE(self.transformation, solver)
res = calc.solve(self.driver)
self.assertAlmostEqual(res.electronic_energy, self.expected, places=6)
def quick_simulate(circuit, shots=1024, x="0", verbose=False):
"""simulates circuit with given input
Args:
circuit (QuantumCircuit): Circuit to simulate. Currently no more than 2 registers supported
shots (int, optional): number of shots to simulate. Default 1024
x (str, optional): input string eg "11" would apply an X gate to first 2 qubits. Default "0"
verbose (bool, optional): prints extra output
Returns:
dict[str:int]: results.get_counts()
Raises:
QiskitError: if circuit has more than two registers
"""
names = []
regs = []
for q in circuit.qubits:
name = q.register.name
size = len(q.register)
if name not in names:
names.append(name)
regs.append(size)
if verbose:
print(names, regs)
# assuming that we only have 2: control + ancillary
qra = QuantumRegister(regs[0], name=names[0])
if len(regs) == 1:
qa = QuantumCircuit(qra)
elif len(regs) == 2:
qran = QuantumRegister(regs[1], name=names[1])
qa = QuantumCircuit(qra, qran)
else:
raise QiskitError("Not yet implemented for more than 2 registers")
if len(x) != sum(regs):
x += "0" * (sum(regs) - len(x))
if verbose:
print(x)
for i, bit in enumerate(x):
if verbose:
print(bit, type(bit))
if bit != "0":
qa.x(i)
qa.barrier()
qa.extend(circuit)
if verbose:
print(qa)
backend = BasicAer.get_backend('qasm_simulator')
results = execute(qa, backend=backend, shots=shots).result()
answer = results.get_counts()
return answer
def test_default(self):
"""Default execution"""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(self.problem)
self.assertAlmostEqual(res.electronic_energies[0],
self.expected,
places=6)
def test_natural_gradients_invalid(self):
"""test that an exception is thrown when an invalid gradient method is used"""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
grad = NaturalGradient(grad_method="fin_diff",
qfi_method="lin_comb_full",
regularization="ridge")
calc = AdaptVQE(self.qubit_converter, solver, gradient=grad)
with self.assertRaises(QiskitNatureError):
_ = calc.solve(self.problem)
def test_gradient(self, grad_method):
"""test for different gradient methods"""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
grad = Gradient(grad_method, epsilon=1.0)
calc = AdaptVQE(self.qubit_converter, solver, gradient=grad)
res = calc.solve(self.problem)
self.assertAlmostEqual(res.electronic_energies[0],
self.expected,
places=6)
def test_delta_and_gradient(self):
"""test for when delta and gradient both are set"""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
delta1 = 0.01
grad = Gradient(grad_method="fin_diff", epsilon=1.0)
with self.assertRaises(TypeError):
_ = AdaptVQE(self.qubit_converter,
solver,
delta=delta1,
gradient=grad)
def test_delta(self):
"""test for when delta is set instead of gradient"""
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
delta1 = 0.01
with warnings.catch_warnings(record=True):
warnings.simplefilter("always")
calc = AdaptVQE(self.qubit_converter, solver, delta=delta1)
res = calc.solve(self.problem)
self.assertAlmostEqual(res.electronic_energies[0],
self.expected,
places=6)
def test_aux_ops_reusability(self):
""" Test that the auxiliary operators can be reused """
# Regression test against #1475
solver = VQEUCCSDFactory(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = AdaptVQE(self.transformation, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = [FermionicOperator(h_1, h_2)]
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.driver, aux_ops)
assert all([a == b for a, b in zip(aux_ops, aux_ops_copy)])
def test_aux_ops_reusability(self):
"""Test that the auxiliary operators can be reused"""
# Regression test against #1475
solver = VQEUCCFactory(QuantumInstance(BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = [build_ferm_op_from_ints(h_1, h_2)]
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.problem)
assert all(
frozenset(a.to_list()) == frozenset(b.to_list()) for a, b in zip(aux_ops, aux_ops_copy)
)
def test_LiH(self):
"""Lih test"""
driver = PySCFDriver(
atom="Li .0 .0 .0; H .0 .0 1.6",
unit=UnitsType.ANGSTROM,
basis="sto3g",
)
transformer = ActiveSpaceTransformer(num_electrons=2,
num_molecular_orbitals=3)
problem = ElectronicStructureProblem(driver, [transformer])
solver = VQEUCCFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(problem)
self.assertAlmostEqual(res.electronic_energies[0],
-8.855126478,
places=6)
def test_entanglement(self):
"""
Test entanglement circuits of Ignis verification -
GHZ, MQC, parity oscillations
"""
num_qubits = 5 # number of qubits
sim = BasicAer.get_backend('qasm_simulator')
# test simple GHZc
circ = linear.get_ghz_simple(num_qubits, measure=True)
counts = execute(circ, sim, shots=1024).result().get_counts(circ)
self.assertTrue(
counts.get('00000', 0) + counts.get('11111', 0) == 1024)
# test MQC
circ, delta = linear.get_ghz_mqc_para(num_qubits)
theta_range = np.linspace(0, 2 * np.pi, 16)
circuits = [
circ.bind_parameters({delta: theta_val})
for theta_val in theta_range
]
for circ in circuits:
counts = execute(circ, sim, shots=1024).result().get_counts(circ)
self.assertTrue(
(counts.get('00000', 0) == 1024)
or (counts.get('00000', 0) + counts.get('00001', 0)) == 1024)
# test parity oscillations
circ, params = linear.get_ghz_po_para(num_qubits)
theta_range = np.linspace(0, 2 * np.pi, 16)
circuits = [
circ.bind_parameters({
params[0]: theta_val,
params[1]: -theta_val
}) for theta_val in theta_range
]
for circ in circuits:
counts = execute(circ, sim, shots=1024).result().get_counts(circ)
even_counts = sum(key.count('1') % 2 == 0 for key in counts.keys())
odd_counts = sum(key.count('1') % 2 == 1 for key in counts.keys())
self.assertTrue(even_counts in (0, 16))
self.assertTrue(odd_counts in (0, 16))
def test_custom_excitation_pool(self):
""" Test custom excitation pool """
class CustomFactory(VQEUCCSDFactory):
"""A custom MES factory."""
def get_solver(self, transformation):
solver = super().get_solver(transformation)
# Here, we can create essentially any custom excitation pool.
# For testing purposes only, we simply select some hopping operator already
# available in the variational form object.
# pylint: disable=no-member
custom_excitation_pool = [solver.var_form._hopping_ops[2]]
solver.var_form.excitation_pool = custom_excitation_pool
return solver
solver = CustomFactory(
QuantumInstance(BasicAer.get_backend('statevector_simulator')))
calc = AdaptVQE(self.transformation, solver)
res = calc.solve(self.driver)
self.assertAlmostEqual(res.electronic_energy, self.expected, places=6)
def test_custom_excitation_pool(self):
"""Test custom excitation pool"""
class CustomFactory(VQEUCCFactory):
"""A custom MES factory."""
def get_solver(self, problem, qubit_converter):
solver = super().get_solver(problem, qubit_converter)
# Here, we can create essentially any custom excitation pool.
# For testing purposes only, we simply select some hopping operator already
# available in the ansatz object.
custom_excitation_pool = [solver.ansatz.operators[2]]
solver.ansatz.operators = custom_excitation_pool
return solver
solver = CustomFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(self.problem)
self.assertAlmostEqual(res.electronic_energies[0],
self.expected,
places=6)
def test_aux_ops_reusability(self):
"""Test that the auxiliary operators can be reused"""
# Regression test against #1475
solver = VQEUCCFactory(
QuantumInstance(BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
modes = 4
h_1 = np.eye(modes, dtype=complex)
h_2 = np.zeros((modes, modes, modes, modes))
aux_ops = ElectronicEnergy([
OneBodyElectronicIntegrals(ElectronicBasis.MO, (h_1, None)),
TwoBodyElectronicIntegrals(ElectronicBasis.MO,
(h_2, None, None, None)),
]).second_q_ops()
aux_ops_copy = copy.deepcopy(aux_ops)
_ = calc.solve(self.problem)
assert all(
frozenset(a.to_list()) == frozenset(b.to_list())
for a, b in zip(aux_ops, aux_ops_copy))
def optmization_levels(self):
backend = BasicAer.get_backend('qasm_simulator')
circuit = self.circuit
seed_simulator = self.seed_simulator
seed_transpiler = seed_simulator
counts_0 = execute(
deepcopy(circuit),
backend,
optimization_level=0,
seed_simulator=seed_simulator,
seed_transpiler=seed_transpiler).result().get_counts()
counts_1 = execute(
deepcopy(circuit),
backend,
optimization_level=1,
seed_simulator=seed_simulator,
seed_transpiler=seed_transpiler,
).result().get_counts()
counts_2 = execute(
deepcopy(circuit),
backend,
optimization_level=2,
seed_simulator=seed_simulator,
seed_transpiler=seed_transpiler,
).result().get_counts()
if self.random_bool:
counts_3 = execute(
deepcopy(circuit),
backend,
optimization_level=3,
seed_simulator=seed_simulator,
seed_transpiler=seed_transpiler,
).result().get_counts()
else:
counts_3 = deepcopy(counts_2)
self.assertEqualCounts(counts_0, counts_1, counts_2, counts_3)
def test_custom_minimum_eigensolver(self):
"""Test custom MES"""
class CustomFactory(VQEUCCFactory):
"""A custom MES Factory"""
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
solver = CustomFactory(quantum_instance=QuantumInstance(
BasicAer.get_backend("statevector_simulator")))
calc = AdaptVQE(self.qubit_converter, solver)
res = calc.solve(self.problem)
self.assertAlmostEqual(res.electronic_energies[0],
self.expected,
places=6)