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
