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 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 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 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)
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
def test_ce_fail(self):
""" Test no operator """
algo = NumPyEigensolver()
with self.assertRaises(AquaError):
_ = algo.run()
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
def Exact_solver(qubitOp):
ex = NumPyEigensolver(qubitOp)
result = ex.run()
ref = result['eigenvalues']
return np.real(ref)[0]
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
