Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.
n_spatial_orbitals = n_qubits // 2
n_occupied = int(numpy.ceil(n_electrons / 2))
n_virtual = n_spatial_orbitals - n_occupied
# Unpack amplitudes
n_single_amplitudes = n_occupied * n_virtual
# Single amplitudes
t1 = packed_amplitudes[:n_single_amplitudes]
# Double amplitudes associated with one spatial occupied-virtual pair
t2_1 = packed_amplitudes[n_single_amplitudes:2 * n_single_amplitudes]
# Double amplitudes associated with two spatial occupied-virtual pairs
t2_2 = packed_amplitudes[2 * n_single_amplitudes:]
# Initialize operator
generator = FermionOperator()
# Generate excitations
spin_index_functions = [up_index, down_index]
# Generate all spin-conserving single and double excitations derived
# from one spatial occupied-virtual pair
for i, (p, q) in enumerate(
itertools.product(range(n_virtual), range(n_occupied))):
# Get indices of spatial orbitals
virtual_spatial = n_occupied + p
occupied_spatial = q
for spin in range(2):
# Get the functions which map a spatial orbital index to a
# spin orbital index
this_index = spin_index_functions[spin]
Args:
n_spatial_orbitals: number of spatial orbitals (n_qubits + 1 // 2).
Returns:
operator (FermionOperator): corresponding to the s+ operator over
n_spatial_orbitals.
Note:
The indexing convention used is that even indices correspond to
spin-up (alpha) modes and odd indices correspond to spin-down (beta)
modes.
"""
if not isinstance(n_spatial_orbitals, int):
raise TypeError("n_orbitals must be specified as an integer")
fermion_identity = FermionOperator(())
operator = (s_minus_operator(n_spatial_orbitals) *
s_plus_operator(n_spatial_orbitals))
operator += (sz_operator(n_spatial_orbitals) *
(sz_operator(n_spatial_orbitals) + fermion_identity))
return operator
# Make sure we're dealing with a fermion operator from a molecule.
if not fermion_operator.is_two_body_number_conserving():
raise OperatorSpecificationError(
'Operator is not two-body number conserving.')
# Normal order and begin looping.
normal_ordered_input = normal_ordered(fermion_operator)
chemist_ordered_operator = FermionOperator()
for term, coefficient in normal_ordered_input.terms.items():
if len(term) == 2 or not len(term):
chemist_ordered_operator += FermionOperator(term, coefficient)
else:
# Possibly add new one-body term.
if term[1][0] == term[2][0]:
new_one_body_term = (term[0], term[3])
chemist_ordered_operator += FermionOperator(
new_one_body_term, coefficient)
# Reorder two-body term.
new_two_body_term = (term[0], term[2], term[1], term[3])
chemist_ordered_operator += FermionOperator(
new_two_body_term, -coefficient)
return chemist_ordered_operator
if (x_dimension > 2) and ((site + 1) % x_dimension == 0):
right_neighbor -= x_dimension
if (y_dimension > 2) and (site + x_dimension + 1 > n_sites):
bottom_neighbor -= x_dimension * y_dimension
# Add transition to neighbor on right
if (site + 1) % x_dimension or (periodic and x_dimension > 2):
# Add spin-up hopping term.
operators = ((up_index(site), 1), (up_index(right_neighbor), 0))
hopping_term = FermionOperator(operators, -tunneling)
mean_field_dwave_model += hopping_term
mean_field_dwave_model += hermitian_conjugated(hopping_term)
# Add spin-down hopping term
operators = ((down_index(site), 1),
(down_index(right_neighbor), 0))
hopping_term = FermionOperator(operators, -tunneling)
mean_field_dwave_model += hopping_term
mean_field_dwave_model += hermitian_conjugated(hopping_term)
# Add pairing term
operators = ((up_index(site), 1),
(down_index(right_neighbor), 1))
pairing_term = FermionOperator(operators, sc_gap / 2.)
operators = ((down_index(site), 1),
(up_index(right_neighbor), 1))
pairing_term += FermionOperator(operators, -sc_gap / 2.)
mean_field_dwave_model -= pairing_term
mean_field_dwave_model -= hermitian_conjugated(pairing_term)
# Add transition to neighbor below.
if site + x_dimension + 1 <= n_sites or (periodic and y_dimension > 2):
# Add spin-up hopping term.
def _majorana_term_to_fermion_operator(term):
converted_term = FermionOperator(())
for index in term:
j, b = divmod(index, 2)
if b:
converted_op = FermionOperator((j, 0), -1j)
converted_op += FermionOperator((j, 1), 1j)
else:
converted_op = FermionOperator((j, 0))
converted_op += FermionOperator((j, 1))
converted_term *= converted_op
return converted_term
# A single round of odd-even transposition sort.
for i in range(parity, n_qubits - 1, 2):
# Always keep the max on the left to avoid having to normal order.
left = max(input_ordering[i], input_ordering[i + 1])
right = min(input_ordering[i], input_ordering[i + 1])
# Calculate the hopping operators in the Hamiltonian.
left_hopping_operator = FermionOperator(
((left, 1), (right, 0)), hamiltonian.terms.get(
((left, 1), (right, 0)), 0.0))
right_hopping_operator = FermionOperator(
((right, 1), (left, 0)), hamiltonian.terms.get(
((right, 1), (left, 0)), 0.0))
# Calculate the two-number operator l^ r^ l r in the Hamiltonian.
two_number_operator = FermionOperator(
((left, 1), (right, 1), (left, 0), (right, 0)),
hamiltonian.terms.get(
((left, 1), (right, 1), (left, 0), (right, 0)), 0.0))
if not external_potential_at_end:
# Calculate the left number operator, left^ left.
left_number_operator = FermionOperator(
((left, 1), (left, 0)), hamiltonian.terms.get(
((left, 1), (left, 0)), 0.0))
# Calculate the right number operator, right^ right.
right_number_operator = FermionOperator(
((right, 1), (right, 0)), hamiltonian.terms.get(
((right, 1), (right, 0)), 0.0))
# Divide single-number terms by n_qubits-1 to avoid over-accounting
for momenta_indices in grid.all_points_indices():
momenta = grid.momentum_vector(momenta_indices)
momenta_squared = momenta.dot(momenta)
if momenta_squared == 0:
continue
cos_index = momenta.dot(coordinate_j - coordinate_p)
coefficient = (prefactor / momenta_squared *
periodic_hash_table[nuclear_term[0]] *
numpy.cos(cos_index))
for spin_p in spins:
orbital_p = grid.orbital_id(pos_indices, spin_p)
operators = ((orbital_p, 1), (orbital_p, 0))
if operator is None:
operator = FermionOperator(operators, coefficient)
else:
operator += FermionOperator(operators, coefficient)
return operator
def _diagonal_coulomb_hamiltonian_to_fermion_operator(operator):
fermion_operator = FermionOperator()
n_qubits = count_qubits(operator)
fermion_operator += FermionOperator((), operator.constant)
for p, q in itertools.product(range(n_qubits), repeat=2):
fermion_operator += FermionOperator(
((p, 1), (q, 0)),
operator.one_body[p, q])
fermion_operator += FermionOperator(
((p, 1), (p, 0), (q, 1), (q, 0)),
operator.two_body[p, q])
return fermion_operator