def setUp(self):
"""Setup."""
super().setUp()
try:
atom = 'H .0 .0 .7414; H .0 .0 .0'
pyscf_driver = PySCFDriver(atom=atom,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
self.molecule = pyscf_driver.run()
warnings.filterwarnings('ignore', category=DeprecationWarning)
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=False,
orbital_reduction=[])
warnings.filterwarnings('always', category=DeprecationWarning)
qubit_op, _ = core.run(self.molecule)
exact_eigensolver = NumPyEigensolver(qubit_op,
k=2**qubit_op.num_qubits)
result = exact_eigensolver.run()
self.reference = result.eigenvalues.real
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
def __init__(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None,
filter_criterion: Callable[
[Union[List,
np.ndarray], float, Optional[List[float]]], bool] = None
) -> None:
"""
Args:
operator: Operator instance
aux_operators: Auxiliary operators to be evaluated at minimum eigenvalue
filter_criterion: callable that allows to filter eigenvalues/eigenstates. The minimum
eigensolver is only searching over feasible states and returns an eigenstate that
has the smallest eigenvalue among feasible states. The callable has the signature
`filter(eigenstate, eigenvalue, aux_values)` and must return a boolean to indicate
whether to consider this value or not. If there is no
feasible element, the result can even be empty.
"""
self._ces = NumPyEigensolver(operator=operator,
k=1,
aux_operators=aux_operators,
filter_criterion=filter_criterion)
# TODO remove
self._ret = {} # type: Dict[str, Any]
def test_ce(self):
""" Test basics """
algo = NumPyEigensolver(self.qubit_op, aux_operators=[])
result = algo.run()
self.assertEqual(len(result.eigenvalues), 1)
self.assertEqual(len(result.eigenstates), 1)
self.assertAlmostEqual(result.eigenvalues[0], -1.85727503 + 0j)
def test_ce_k4(self):
""" Test for k=4 eigenvalues """
algo = NumPyEigensolver(self.qubit_op, k=4, aux_operators=[])
result = algo.run()
self.assertEqual(len(result.eigenvalues), 4)
self.assertEqual(len(result.eigenstates), 4)
np.testing.assert_array_almost_equal(result.eigenvalues.real,
[-1.85727503, -1.24458455, -0.88272215, -0.22491125])
def test_mapping(self):
""" mapping test """
qubit_op = self.bos_op.mapping('direct', threshold=1e-5)
algo = NumPyEigensolver(qubit_op, k=100)
result = algo.run()
vecs = result['eigenstates']
energies = result['eigenvalues']
gs_energy = self.bos_op.ground_state_energy(vecs, energies)
self.assertAlmostEqual(gs_energy, self.reference_energy, places=4)
def eigen_decomposition(molecule,H_op,dE,A_op,dA,outf):
ee = NumPyEigensolver(operator=H_op,k=2**H_op.num_qubits,aux_operators=A_op)
ee = ee.run()
t = PrettyTable(['Energy','N','Sz','S^2','Dx','Dy','Dz'])
for x,v in zip(ee['eigenvalues'],ee['aux_operator_eigenvalues']):
x,v = np.real(x+dE),[np.real(vi[0]+dAi) for vi,dAi in zip(v,dA)]
if(x<molecule.hf_energy):
t.add_row([str(round(x,6))]+[str(round(w,6)) for w in v])
outf.write(str(t))
outf.write("\n")
def __init__(self,
operator: Optional[BaseOperator] = None,
aux_operators: Optional[List[BaseOperator]] = None) -> None:
"""
Args:
operator: Operator instance
aux_operators: Auxiliary operators to be evaluated at minimum eigenvalue
"""
self._ces = NumPyEigensolver(operator, 1, aux_operators)
self._ret = {} # TODO remove
def test_ce_k4_filtered(self):
""" Test for k=4 eigenvalues with filter """
# define filter criterion
# pylint: disable=unused-argument
def criterion(x, v, a_v):
return v >= -1
algo = NumPyEigensolver(self.qubit_op, k=4, aux_operators=[], filter_criterion=criterion)
result = algo.run()
self.assertEqual(len(result.eigenvalues), 2)
self.assertEqual(len(result.eigenstates), 2)
np.testing.assert_array_almost_equal(result.eigenvalues.real, [-0.88272215, -0.22491125])
def __init__(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None
) -> None:
"""
Args:
operator: Operator instance
aux_operators: Auxiliary operators to be evaluated at minimum eigenvalue
"""
self._ces = NumPyEigensolver(operator, 1, aux_operators)
# TODO remove
self._ret = {} # type: Dict[str, Any]
def test_ce_k4_filtered_empty(self):
""" Test for k=4 eigenvalues with filter always returning False """
# define filter criterion
# pylint: disable=unused-argument
def criterion(x, v, a_v):
return False
algo = NumPyEigensolver(self.qubit_op,
k=4,
aux_operators=[],
filter_criterion=criterion)
result = algo.run()
self.assertEqual(len(result.eigenvalues), 0)
self.assertEqual(len(result.eigenstates), 0)
def test_harmonic_basis(self):
"""test for obtaining the hamiltonian in the harmonic basis"""
num_modals = 2
hamiltonian_in_harmonic_basis = \
self.gaussian_log_data.compute_harmonic_modes(num_modals, truncation_order=2)
basis = [num_modals, num_modals, num_modals,
num_modals] # 4 modes and 2 modals per mode
bos_op = BosonicOperator(hamiltonian_in_harmonic_basis, basis)
qubit_op = bos_op.mapping('direct', threshold=1e-5)
algo = NumPyEigensolver(qubit_op, k=100)
result = algo.run()
vecs = result['eigenstates']
energies = result['eigenvalues']
gs_energy = bos_op.ground_state_energy(vecs, energies)
self.assertAlmostEqual(gs_energy, self.reference_energy, places=6)
def calculate(self, G, cost_matrix, starting_node = 0):
# Create nodes array for the TSP solver in Qiskit
G.nodes[0]['pos']
coords = []
for node in G.nodes:
coords.append(G.nodes[0]['pos'])
tsp_instance = tsp.TspData(name = "TSP", dim = len(G.nodes), coord = coords, w = cost_matrix)
qubitOp, offset = tsp.get_operator(tsp_instance)
ee = NumPyEigensolver(qubitOp, k=1)
result = ee.run()
x = sample_most_likely(result['eigenstates'][0])
return tsp.get_tsp_solution(x)
def get_solver(self, transformation: Transformation) -> Eigensolver:
"""Returns a NumPyEigensolver with the desired filter
Args:
transformation: a fermionic/bosonic qubit operator transformation.
Returns:
A NumPyEigensolver suitable to compute the ground state of the molecule
transformed by ``transformation``.
"""
filter_criterion = self._filter_criterion
if not filter_criterion and self._use_default_filter_criterion:
filter_criterion = transformation.get_default_filter_criterion()
npe = NumPyEigensolver(filter_criterion=filter_criterion, k=self.k)
return npe
def setUp(self):
super().setUp()
aqua_globals.random_seed = 8
try:
self.driver = PySCFDriver(atom='H .0 .0 .0; H .0 .0 0.75',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
self.reference_energies = [-1.8427016, -1.8427016 + 0.5943372, -1.8427016 + 0.95788352,
-1.8427016 + 1.5969296]
self.transformation = \
FermionicTransformation(qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER)
solver = NumPyEigensolver()
self.ref = solver
self.quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_transpiler=90, seed_simulator=12)
def get_results(H_op, A_op, molecule, core, algo_result, outfile):
mgsr = core._process_algorithm_result_ground_state(algo_result)
dE, dA = get_offsets(molecule, core, mgsr)
res_vqe = [
algo_result['optimal_value'] + dE,
algo_result['aux_operator_eigenvalues'][0][0] + dA[0],
algo_result['aux_operator_eigenvalues'][1][0] + dA[1],
algo_result['aux_operator_eigenvalues'][2][0] + dA[2],
-algo_result['aux_operator_eigenvalues'][3][0] + dA[3],
-algo_result['aux_operator_eigenvalues'][4][0] + dA[4],
-algo_result['aux_operator_eigenvalues'][5][0] + dA[5]
]
ee = NumPyEigensolver(operator=H_op, k=1, aux_operators=A_op).run()
res_ee = [
ee['eigenvalues'][0] + dE,
ee['aux_operator_eigenvalues'][0][0][0] + dA[0],
ee['aux_operator_eigenvalues'][0][1][0] + dA[1],
ee['aux_operator_eigenvalues'][0][2][0] + dA[2],
-ee['aux_operator_eigenvalues'][0][3][0] + dA[3],
-ee['aux_operator_eigenvalues'][0][4][0] + dA[4],
-ee['aux_operator_eigenvalues'][0][5][0] + dA[5]
]
t = PrettyTable([
'method', 'Energy [Ha]', 'N', 'Sz [hbar]', 'S^2 [hbar]', 'Dx [Ha]',
'Dy [Ha]', 'Dz [Ha]'
])
t.add_row(['VQE'] + [str(round(np.real(x), 6)) for x in res_vqe])
t.add_row(['FCI'] + [str(round(np.real(x), 6)) for x in res_ee])
outfile.write(str(t))
outfile.write("\n")
return algo_result
def supports_aux_operators(cls) -> bool:
return NumPyEigensolver.supports_aux_operators()
class NumPyMinimumEigensolver(ClassicalAlgorithm, MinimumEigensolver):
"""
The Numpy Minimum Eigensolver algorithm.
"""
def __init__(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None
) -> None:
"""
Args:
operator: Operator instance
aux_operators: Auxiliary operators to be evaluated at minimum eigenvalue
"""
self._ces = NumPyEigensolver(operator, 1, aux_operators)
# TODO remove
self._ret = {} # type: Dict[str, Any]
@property
def operator(self) -> Optional[OperatorBase]:
return self._ces.operator
@operator.setter
def operator(self, operator: Union[OperatorBase,
LegacyBaseOperator]) -> None:
self._ces.operator = operator
@property
def aux_operators(self) -> Optional[List[Optional[OperatorBase]]]:
return self._ces.aux_operators
@aux_operators.setter
def aux_operators(
self,
aux_operators: Optional[List[Optional[Union[OperatorBase,
LegacyBaseOperator]]]]
) -> None:
self._ces.aux_operators = aux_operators
def supports_aux_operators(self) -> bool:
return self._ces.supports_aux_operators()
def compute_minimum_eigenvalue(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None
) -> MinimumEigensolverResult:
super().compute_minimum_eigenvalue(operator, aux_operators)
return self._run()
def _run(self) -> MinimumEigensolverResult:
"""
Run the algorithm to compute up to the minimum eigenvalue.
Returns:
dict: Dictionary of results
"""
result_ces = self._ces.run()
self._ret = self._ces._ret # TODO remove
result = MinimumEigensolverResult()
result.eigenvalue = result_ces.eigenvalues[0]
result.eigenstate = result_ces.eigenstates[0]
if result_ces.aux_operator_eigenvalues is not None:
if len(result_ces.aux_operator_eigenvalues) > 0:
result.aux_operator_eigenvalues = result_ces.aux_operator_eigenvalues[
0]
logger.debug('NumPyMinimumEigensolver dict:\n%s',
pprint.pformat(result.data, indent=4))
return result
class NumPyMinimumEigensolver(ClassicalAlgorithm, MinimumEigensolver):
"""
The Numpy Minimum Eigensolver algorithm.
"""
def __init__(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None,
filter_criterion: Callable[
[Union[List,
np.ndarray], float, Optional[List[float]]], bool] = None
) -> None:
"""
Args:
operator: Operator instance
aux_operators: Auxiliary operators to be evaluated at minimum eigenvalue
filter_criterion: callable that allows to filter eigenvalues/eigenstates. The minimum
eigensolver is only searching over feasible states and returns an eigenstate that
has the smallest eigenvalue among feasible states. The callable has the signature
`filter(eigenstate, eigenvalue, aux_values)` and must return a boolean to indicate
whether to consider this value or not. If there is no
feasible element, the result can even be empty.
"""
self._ces = NumPyEigensolver(operator=operator,
k=1,
aux_operators=aux_operators,
filter_criterion=filter_criterion)
# TODO remove
self._ret = {} # type: Dict[str, Any]
@property
def operator(self) -> Optional[OperatorBase]:
return self._ces.operator
@operator.setter
def operator(self, operator: Union[OperatorBase,
LegacyBaseOperator]) -> None:
self._ces.operator = operator
@property
def aux_operators(self) -> Optional[List[Optional[OperatorBase]]]:
return self._ces.aux_operators
@aux_operators.setter
def aux_operators(
self,
aux_operators: Optional[List[Optional[Union[OperatorBase,
LegacyBaseOperator]]]]
) -> None:
self._ces.aux_operators = aux_operators
@property
def filter_criterion(
self
) -> Optional[Callable[
[Union[List, np.ndarray], float, Optional[List[float]]], bool]]:
""" returns the filter criterion if set """
return self._ces.filter_criterion
@filter_criterion.setter
def filter_criterion(
self, filter_criterion: Optional[Callable[
[Union[List, np.ndarray], float, Optional[List[float]]], bool]]
) -> None:
""" set the filter criterion """
self._ces.filter_criterion = filter_criterion
def supports_aux_operators(self) -> bool:
return self._ces.supports_aux_operators()
def compute_minimum_eigenvalue(
self,
operator: Optional[Union[OperatorBase, LegacyBaseOperator]] = None,
aux_operators: Optional[List[Optional[Union[
OperatorBase, LegacyBaseOperator]]]] = None
) -> MinimumEigensolverResult:
super().compute_minimum_eigenvalue(operator, aux_operators)
return self._run()
def _run(self) -> MinimumEigensolverResult:
"""
Run the algorithm to compute up to the minimum eigenvalue.
Returns:
dict: Dictionary of results
"""
result_ces = self._ces.run()
self._ret = self._ces._ret # TODO remove
result = MinimumEigensolverResult()
if len(result_ces.eigenvalues) > 0:
result.eigenvalue = result_ces.eigenvalues[0]
result.eigenstate = result_ces.eigenstates[0]
if result_ces.aux_operator_eigenvalues is not None:
if len(result_ces.aux_operator_eigenvalues) > 0:
result.aux_operator_eigenvalues = result_ces.aux_operator_eigenvalues[
0]
else:
result.eigenvalue = None
result.eigenstate = None
result.aux_operator_eigenvalues = None
logger.debug('NumPyMinimumEigensolver dict:\n%s',
pprint.pformat(result.data, indent=4))
return result
def test_ce_fail(self):
""" Test no operator """
algo = NumPyEigensolver()
with self.assertRaises(AquaError):
_ = algo.run()
def pauli_operator_to_dict(pauli_operator):
d = pauli_operator.to_dict()
paulis = d['paulis']
paulis_dict = {}
for x in paulis:
label = x['label']
coeff = x['coeff']['real']
paulis_dict[label] = coeff
return paulis_dict
pauli_dict = pauli_operator_to_dict(H)
def energy(parameters):
energy = 0
for pauli_name in pauli_dict.keys():
energy += pauli_dict[pauli_name] * expectation(parameters, pauli_name)
return energy
params = list(np.pi * (np.random.random(size=2) - 0.5))
tol = 1e-4
opt_vqe = minimize(energy, params, method='Powell', tol=tol)
exact_result = NumPyEigensolver(H).run()
reference_energy = min(np.real(exact_result.eigenvalues))
print(f'Reference minimum energy (eigenvalue) of H: {reference_energy}')
print(f'Minimum energy (eigenvalue) of H: {np.round(opt_vqe.fun, 5)}')
print(f'Optimized params phi1: {np.round(opt_vqe.x[0], 5)}, phi2 {np.round(opt_vqe.x[1], 5)}')
def Exact_solver(qubitOp):
ex = NumPyEigensolver(qubitOp)
result = ex.run()
ref = result['eigenvalues']
return np.real(ref)[0]
qubitOp = ferOp.mapping(map_type='parity', threshold=0.00000001)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
shift = energy_shift + repulsion_energy
return qubitOp, num_particles, num_spin_orbitals, shift
backend = BasicAer.get_backend("statevector_simulator")
distances = np.arange(0.5, 1, 0.1)
exact_energies = []
vqe_energies = []
# optimizer = SLSQP(maxiter=5)
optimizer = GRABER()
vqe_time = 0
for dist in distances:
qubitOp, num_particles, num_spin_orbitals, shift = get_qubit_op(dist)
result = NumPyEigensolver(qubitOp).run()
exact_energies.append(np.real(result.eigenvalues) + shift)
initial_state = HartreeFock(
num_spin_orbitals,
num_particles,
qubit_mapping='parity'
)
var_form = UCCSD(
num_orbitals=num_spin_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping='parity'
)
begin = time.time()
vqe = VQE(qubitOp, var_form, optimizer)
vqe_result = np.real(vqe.run(backend)['eigenvalue'] + shift)
def taper(molecule, core, qubit_op, A_op, outf):
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
the_ancillas = A_op
nsym = len(z2_symmetries.sq_paulis)
the_tapered_op = qubit_op
sqlist = None
z2syms = None
outf.write('\n\nstart tapering... \n\n')
if (nsym > 0):
outf.write('Z2 symmetries found:\n')
for symm in z2_symmetries.symmetries:
outf.write(symm.to_label() + '\n')
outf.write('single qubit operators found:\n')
for sq in z2_symmetries.sq_paulis:
outf.write(sq.to_label() + '\n')
outf.write('cliffords found:\n')
for clifford in z2_symmetries.cliffords:
outf.write(clifford.print_details() + '\n')
outf.write('single-qubit list: {}\n'.format(z2_symmetries.sq_list))
tapered_ops = z2_symmetries.taper(qubit_op)
for tapered_op in tapered_ops:
outf.write(
"Number of qubits of tapered qubit operator: {}\n".format(
tapered_op.num_qubits))
ee = NumPyEigensolver(qubit_op, k=1)
result = core.process_algorithm_result(ee.run())
for line in result[0]:
outf.write(line + '\n')
smallest_eig_value = 99999999999999
smallest_idx = -1
for idx in range(len(tapered_ops)):
ee = NumPyEigensolver(tapered_ops[idx], k=1)
curr_value = ee.run()['eigenvalues'][0]
if curr_value < smallest_eig_value:
smallest_eig_value = curr_value
smallest_idx = idx
outf.write(
"Lowest eigenvalue of the {}-th tapered operator (computed part) is {:.12f}\n"
.format(idx, curr_value))
the_tapered_op = tapered_ops[smallest_idx]
the_coeff = tapered_ops[smallest_idx].z2_symmetries.tapering_values
outf.write(
"The {}-th tapered operator matches original ground state energy, with corresponding symmetry sector of {}\n"
.format(smallest_idx, the_coeff))
sqlist = the_tapered_op.z2_symmetries.sq_list
z2syms = the_tapered_op.z2_symmetries
the_ancillas = []
for A in A_op:
A_taper = z2_symmetries.taper(A)
if (type(A_taper) == list):
the_ancillas.append(A_taper[smallest_idx])
else:
the_ancillas.append(A_taper)
outf.write('\n\n...finish tapering \n\n')
return the_tapered_op, the_ancillas, z2syms, sqlist
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device.properties())
quantum_noise_instance = QuantumInstance(
backend=backend,
shots=8192,
noise_model=noise_model,
coupling_map=coupling_map,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=30)
quantum_non_noise_instance = QuantumInstance(
backend=backend,
shots=8192,
coupling_map=coupling_map,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=30)
# Configure the optimizer, the variational form, and the VQE instance
exact_solution = NumPyEigensolver(qubitOp).run()
print("Exact Result:",
np.real(exact_solution.eigenvalues) + molecule.nuclear_repulsion_energy)
optimizer = SPSA(maxiter=100)
var_form = EfficientSU2(qubitOp.num_qubits, entanglement="linear")
vqe = VQE(qubitOp, var_form, optimizer=optimizer)
noise_ret = vqe.run(quantum_noise_instance)
non_noise_ret = vqe.run(quantum_non_noise_instance)
noise_vqe_result = np.real(noise_ret['eigenvalue'] +
molecule.nuclear_repulsion_energy)
non_noise_vqe_result = np.real(non_noise_ret['eigenvalue'] +
molecule.nuclear_repulsion_energy)
print("VQE Result with noise:", noise_vqe_result)
print("VQE Result without noise:", non_noise_vqe_result)
