def mapping(self, map_type, threshold=0.00000001): self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a_list = self._jordan_wigner_mode(n) elif map_type == 'parity': a_list = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a_list = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError('Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') pauli_list = WeightedPauliOperator(paulis=[]) for h in self._hs: if(h is not None): results = parallel_map(FermionicOperatorNBody._n_body_mapping, [FermionicOperatorNBody._prep_mapping(h[indexes],a_list,indexes) for indexes in list(itertools.product(range(n), repeat=len(h.shape))) if h[indexes] != 0], num_processes=aqua_globals.num_processes) for result in results: pauli_list += result ''' for h in self._hs: if h is not None: indexes_list = np.argwhere(np.abs(h)>threshold) print(h.shape,len(indexes_list)) for indexes in indexes_list: h_a = [h[tuple(indexes)]] for i in indexes: h_a.append(a_list[i]) pauli_list += FermionicOperatorNBody._n_body_mapping(h_a) for h in self._hs: if(h is not None): results = parallel_map(FermionicOperatorNBody._n_body_mapping, [FermionicOperatorNBody._prep_mapping(h[indexes],a_list,indexes) for indexes in np.argwhere(np.abs(h)>threshold)], num_processes=aqua_globals.num_processes) for result in results: pauli_list += result ''' pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [self._ph_trans_shift, Pauli.from_label('I' * self._modes)] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list
def mapping(self, map_type, threshold=0.00000001, idx=[None] * 4): self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a_list = self._jordan_wigner_mode(n) elif map_type == 'parity': a_list = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a_list = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError( 'Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') pauli_list = WeightedPauliOperator(paulis=[]) for m, h in enumerate(self._hs): if (h is not None): if (idx[m] is None): results = parallel_map( FermionicOperatorNBody._n_body_mapping, [ FermionicOperatorNBody._prep_mapping( h[indexes], a_list, indexes) for indexes in list( itertools.product(range(n), repeat=len(h.shape))) if h[indexes] != 0 ], num_processes=aqua_globals.num_processes) else: results = parallel_map( FermionicOperatorNBody._n_body_mapping, [ FermionicOperatorNBody._prep_mapping( h[indexes], a_list, indexes) for indexes in idx[m] if np.abs(h[indexes]) > threshold ], num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [ self._ph_trans_shift, Pauli.from_label('I' * self._modes) ] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list
def mapping(self, map_type, threshold=0.00000001): self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a_list = self._jordan_wigner_mode(n) elif map_type == 'parity': a_list = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a_list = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError( 'Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') pauli_list = WeightedPauliOperator(paulis=[]) import time for h in self._hs: t0 = time.time() indexes_list = np.argwhere(np.abs(h) > threshold) t1 = time.time() print("search ", h.shape, t1 - t0) for indexes in indexes_list: t2 = time.time() #print(indexes) h_a = [h[tuple(indexes)]] for i in indexes: h_a.append(a_list[i]) #print(h_a) pauli_list += FermionicOperatorNBody._n_body_mapping(h_a) t3 = time.time() print("pauli ", t3 - t2) pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [ self._ph_trans_shift, Pauli.from_label('I' * self._modes) ] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list
def mapping(self, qubit_mapping: str = 'direct', threshold: float = 1e-8) -> WeightedPauliOperator: """ Maps a bosonic operator into a qubit operator. Args: qubit_mapping: a string giving the type of mapping (only the 'direct' mapping is implemented at this point) threshold: threshold to chop the low contribution paulis Returns: A qubit operator Raises: ValueError: If requested mapping is not supported """ qubit_op = WeightedPauliOperator([]) pau = [] for mode in range(self._num_modes): pau.append(self._direct_mapping(self._basis[mode])) if qubit_mapping == 'direct': for deg in range(self._degree): for element in self._h_mat[deg]: paulis = [] modes = [] coeff = element[1] for i in range(deg + 1): m, bf1, bf2 = element[0][i] modes.append(m) paulis.append((self._one_body_mapping( (1, pau[m][bf1], pau[m][bf2]))).paulis) qubit_op += self._combine(modes, paulis, coeff) qubit_op.chop(threshold) else: raise ValueError('Only the direct mapping is implemented') return qubit_op
def mapping(self, map_type, threshold=0.00000001): """Map fermionic operator to qubit operator. Using multiprocess to speedup the mapping, the improvement can be observed when h2 is a non-sparse matrix. Args: map_type (str): case-insensitive mapping type. "jordan_wigner", "parity", "bravyi_kitaev", "bksf" threshold (float): threshold for Pauli simplification Returns: WeightedPauliOperator: create an Operator object in Paulis form. Raises: QiskitChemistryError: if the `map_type` can not be recognized. """ """ #################################################################### ############ DEFINING MAPPED FERMIONIC OPERATORS ############## #################################################################### """ self._map_type = map_type n = self._modes # number of fermionic modes / qubits map_type = map_type.lower() if map_type == 'jordan_wigner': a = self._jordan_wigner_mode(n) elif map_type == 'parity': a = self._parity_mode(n) elif map_type == 'bravyi_kitaev': a = self._bravyi_kitaev_mode(n) elif map_type == 'bksf': return bksf_mapping(self) else: raise QiskitChemistryError('Please specify the supported modes: ' 'jordan_wigner, parity, bravyi_kitaev, bksf') """ #################################################################### ############ BUILDING THE MAPPED HAMILTONIAN ################ #################################################################### """ pauli_list = WeightedPauliOperator(paulis=[]) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping one-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._one_body_mapping, [(self._h1[i, j], a[i], a[j]) for i, j in itertools.product(range(n), repeat=2) if self._h1[i, j] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if logger.isEnabledFor(logging.DEBUG): logger.debug("Mapping two-body terms to Qubit Hamiltonian:") TextProgressBar(output_handler=sys.stderr) results = parallel_map(FermionicOperator._two_body_mapping, [(self._h2[i, j, k, m], a[i], a[j], a[k], a[m]) for i, j, k, m in itertools.product(range(n), repeat=4) if self._h2[i, j, k, m] != 0], task_args=(threshold,), num_processes=aqua_globals.num_processes) for result in results: pauli_list += result pauli_list.chop(threshold=threshold) if self._ph_trans_shift is not None: pauli_term = [self._ph_trans_shift, Pauli.from_label('I' * self._modes)] pauli_list += WeightedPauliOperator(paulis=[pauli_term]) return pauli_list