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 __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_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 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 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 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 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]
def test_ce_fail(self): """ Test no operator """ algo = NumPyEigensolver() with self.assertRaises(AquaError): _ = algo.run()
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)
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)
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