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