def build_hamiltonian_operators(self, qubit_mapping, two_qubit_reduction,
epsilon, num_particles):
self.M_h_elements = []
self.Q_h_elements = []
self.times_MQ_h = []
for (I, J) in self.elements:
t0 = time.time()
EI, EJ = self.E_mu[I], self.E_mu[J]
MIJ_oper, MIJ_idx = triple_commutator_adj_twobody_nor(
self.n, EI, EJ, self.h)
QIJ_oper, QIJ_idx = triple_commutator_adj_twobody_adj(
self.n, EI, EJ, self.h)
t1 = time.time()
self.logfile.write(
"M,Q elements (H) %d %d --- time for FermionicOperator %f\n" %
(I, J, t1 - t0))
MIJ_oper = MIJ_oper.mapping(map_type=qubit_mapping.value,
threshold=epsilon,
idx=MIJ_idx)
QIJ_oper = QIJ_oper.mapping(map_type=qubit_mapping.value,
threshold=epsilon,
idx=QIJ_idx)
if qubit_mapping == 'parity' and two_qubit_reduction:
MIJ_oper = Z2Symmetries.two_qubit_reduction(
MIJ_oper, num_particles)
QIJ_oper = Z2Symmetries.two_qubit_reduction(
QIJ_oper, num_particles)
self.M_h_elements.append(MIJ_oper)
self.Q_h_elements.append(QIJ_oper)
t2 = time.time()
self.times_MQ_h.append((I, J, t1 - t0, t2 - t1))
self.logfile.write(
"M,Q elements (H) %d %d --- time for Mapping %f\n" %
(I, J, t2 - t1))
def build_operators(self, task, qubit_mapping, two_qubit_reduction,
num_particles, epsilon):
self.matrix_elements_adj_nor[task] = []
self.matrix_elements_adj_adj[task] = []
self.time_statistics[task] = []
# -----
for (I, J) in self.elements:
# ----- computation
t0 = time.time()
EI, EJ = self.E_mu[I], self.E_mu[J]
if (task == 'overlap'):
adj_nor_oper, adj_nor_idx = commutator_adj_nor(self.n, EI, EJ)
adj_adj_oper, adj_adj_idx = commutator_adj_adj(self.n, EI, EJ)
if (task == 'hamiltonian'):
adj_nor_oper, adj_nor_idx = triple_commutator_adj_twobody_nor(
self.n, EI, EJ, self.h)
adj_adj_oper, adj_adj_idx = triple_commutator_adj_twobody_adj(
self.n, EI, EJ, self.h)
if (task == 'diagnosis_number'):
adj_nor_oper, adj_nor_idx = triple_commutator_adj_onebody_nor(
self.n, EI, EJ, self.ne)
adj_adj_oper, adj_adj_idx = triple_commutator_adj_onebody_adj(
self.n, EI, EJ, self.ne)
if (task == 'diagnosis_spin-z'):
adj_nor_oper, adj_nor_idx = triple_commutator_adj_onebody_nor(
self.n, EI, EJ, self.sz)
adj_adj_oper, adj_adj_idx = triple_commutator_adj_onebody_adj(
self.n, EI, EJ, self.sz)
if (task == 'diagnosis_spin-squared'):
adj_nor_oper, adj_nor_idx = triple_commutator_adj_twobody_nor(
self.n, EI, EJ, self.ss)
adj_adj_oper, adj_adj_idx = triple_commutator_adj_twobody_adj(
self.n, EI, EJ, self.ss)
t1 = time.time()
self.logfile.write(
"task: " + task +
" elements %d %d --- time for FermionicOperator %f\n" %
(I, J, t1 - t0))
# ----- mapping
adj_nor_oper = adj_nor_oper.mapping(map_type=qubit_mapping.value,
threshold=epsilon,
idx=adj_nor_idx)
adj_adj_oper = adj_adj_oper.mapping(map_type=qubit_mapping.value,
threshold=epsilon,
idx=adj_adj_idx)
if qubit_mapping.value == 'parity' and two_qubit_reduction:
adj_nor_oper = Z2Symmetries.two_qubit_reduction(
adj_nor_oper, num_particles)
adj_adj_oper = Z2Symmetries.two_qubit_reduction(
adj_adj_oper, num_particles)
self.matrix_elements_adj_nor[task].append(adj_nor_oper)
self.matrix_elements_adj_adj[task].append(adj_adj_oper)
t2 = time.time()
# ----- timings
self.logfile.write("task: " + task +
" elements %d %d --- time for Mapping %f\n" %
(I, J, t2 - t1))
self.time_statistics[task].append((I, J, t1 - t0, t2 - t1))
def build_overlap_operators(self, qubit_mapping, two_qubit_reduction,
epsilon, num_particles):
self.V_elements = []
self.W_elements = []
self.times_VW = []
for (I, J) in self.elements:
t0 = time.time()
EI, EJ = self.E_mu[I], self.E_mu[J]
VIJ_oper, VIJ_idx = commutator_adj_nor(self.n, EI, EJ)
WIJ_oper, WIJ_idx = [None] * 4, [None] * 4
t1 = time.time()
self.logfile.write(
"V,W elements %d %d --- time for FermionicOperator %f\n" %
(I, J, t1 - t0))
VIJ_oper = VIJ_oper.mapping(map_type=qubit_mapping.value,
threshold=epsilon,
idx=VIJ_idx)
if qubit_mapping.value == 'parity' and two_qubit_reduction:
VIJ_oper = Z2Symmetries.two_qubit_reduction(
VIJ_oper, num_particles)
self.V_elements.append(VIJ_oper)
t2 = time.time()
self.times_VW.append((I, J, t1 - t0, t2 - t1))
self.logfile.write("V,W elements %d %d --- time for Mapping %f\n" %
(I, J, t2 - t1))
def get_qubit_op(target_molecule):
geometry, multiplicity, charge = generate_molecule_dict()
driver = PySCFDriver(atom=geometry_convert(target_molecule),
unit=UnitsType.ANGSTROM,
charge=charge[target_molecule],
spin=0,
basis='sto3g')
molecule = driver.run()
repulsion_energy = molecule.nuclear_repulsion_energy
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
one_RDM = make_one_rdm(target_molecule)
w = calculate_noons(one_RDM)
freeze_list, remove_list = generate_freeze_remove_list(w)
remove_list = [x % molecule.num_orbitals for x in remove_list]
freeze_list = [x % molecule.num_orbitals for x in freeze_list]
remove_list = [x - len(freeze_list) for x in remove_list]
remove_list += [
x + molecule.num_orbitals - len(freeze_list) for x in remove_list
]
freeze_list += [x + molecule.num_orbitals for x in freeze_list]
ferOp = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
ferOp, energy_shift = ferOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)
ferOp = ferOp.fermion_mode_elimination(remove_list)
num_spin_orbitals -= len(remove_list)
qubitOp = ferOp.mapping(map_type='bravyi_kitaev', threshold=0.00000001)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
shift = energy_shift + repulsion_energy
return qubitOp, num_particles, num_spin_orbitals, shift
def load_qubitop_for_molecule(molecule_data):
atom_list = [a[0] + ' ' + " ".join([str(elem) for elem in a[1]]) for a in molecule_data['geometry']]
atom = "; ".join(atom_list)
#atom = 'Li .0 .0 .0; H .0 .0 3.9'
basis = molecule_data['basis']
transform = molecule_data['transform']
electrons = molecule_data['electrons']
active = molecule_data['active_orbitals']
driver = PySCFDriver(atom=atom, unit=UnitsType.ANGSTROM, basis=basis, charge=0, spin=0)
molecule = driver.run()
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
#print("# of electrons: {}".format(num_particles))
#print("# of spin orbitals: {}".format(num_spin_orbitals))
freeze_list = [x for x in range(int(active/2), int(num_particles/2))]
remove_list = [-x for x in range(active,molecule.num_orbitals-int(num_particles/2)+int(active/2))]
#print(freeze_list)
#print(remove_list)
if transform == 'BK':
map_type = 'bravyi_kitaev'
elif transform == 'JW':
map_type = 'jordan_wigner'
else:
map_type = 'parity'
remove_list = [x % molecule.num_orbitals for x in remove_list]
freeze_list = [x % molecule.num_orbitals for x in freeze_list]
remove_list = [x - len(freeze_list) for x in remove_list]
remove_list += [x + molecule.num_orbitals - len(freeze_list) for x in remove_list]
freeze_list += [x + molecule.num_orbitals for x in freeze_list]
fermiOp = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals)
energy_shift = 0
if len(freeze_list) > 0:
fermiOp, energy_shift = fermiOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)
if len(remove_list) > 0:
fermiOp = fermiOp.fermion_mode_elimination(remove_list)
num_spin_orbitals -= len(remove_list)
qubitOp = fermiOp.mapping(map_type=map_type, threshold=0.00000001)
if len(freeze_list) > 0 or len(remove_list) >0:
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
#print(qubitOp.print_operators())
num_spin_orbitals= qubitOp.num_qubits
return molecule, qubitOp, map_type, num_particles, num_spin_orbitals