def test_freezing_core(self):
driver = PySCFDriver(atom='H .0 .0 -1.160518; Li .0 .0 0.386839',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
molecule = driver.run()
fer_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
fer_op, energy_shift = fer_op.fermion_mode_freezing([0, 6])
gt = -7.8187092970493755
diff = abs(energy_shift - gt)
self.assertLess(diff, 1e-6)
driver = PySCFDriver(atom='H .0 .0 .0; Na .0 .0 1.888',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
molecule = driver.run()
fer_op = FermionicOperator(h1=molecule.one_body_integrals,
h2=molecule.two_body_integrals)
fer_op, energy_shift = fer_op.fermion_mode_freezing(
[0, 1, 2, 3, 4, 10, 11, 12, 13, 14])
gt = -162.58414559586748
diff = abs(energy_shift - gt)
self.assertLess(diff, 1e-6)
def get_qubit_op(dist):
#atom="Li .0 .0 .0; H .0 .0 " + str(dist)
#atom="Be .0 .0 .0; H .0 .0 -" + str(dist) + "; H .0 .0 " + str(dist)
driver = PySCFDriver("Li .0 .0 .0; H .0 .0 " + str(dist),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
molecule = driver.run()
freeze_list = [0]
remove_list = [-3, -2]
repulsion_energy = molecule.nuclear_repulsion_energy
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
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='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
def lih(dist=1.5):
mol = PySCFDriver(atom=
'H 0.0 0.0 0.0;'\
'Li 0.0 0.0 {}'.format(dist), unit=UnitsType.ANGSTROM, charge=0,
spin=0, basis='sto-3g')
mol = mol.run()
freeze_list = [0]
remove_list = [-3, -2]
repulsion_energy = mol.nuclear_repulsion_energy
num_particles = mol.num_alpha + mol.num_beta
num_spin_orbitals = mol.num_orbitals * 2
remove_list = [x % mol.num_orbitals for x in remove_list]
freeze_list = [x % mol.num_orbitals for x in freeze_list]
remove_list = [x - len(freeze_list) for x in remove_list]
remove_list += [
x + mol.num_orbitals - len(freeze_list) for x in remove_list
]
freeze_list += [x + mol.num_orbitals for x in freeze_list]
ferOp = FermionicOperator(h1=mol.one_body_integrals,
h2=mol.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='parity', threshold=0.00000001)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
shift = energy_shift + repulsion_energy
cHam = op_converter.to_matrix_operator(qubitOp)
cHam = cHam.dense_matrix + shift * numpy.identity(16)
return cHam
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 get_LiH_qubit_op(dist):
"""
Use the qiskit chemistry package to get the qubit Hamiltonian for LiH
Parameters
----------
dist : float
The nuclear separations
Returns
-------
qubitOp : qiskit.aqua.operators.WeightedPauliOperator
Qiskit representation of the qubit Hamiltonian
shift : float
The ground state of the qubit Hamiltonian needs to be corrected by this amount of
energy to give the real physical energy. This includes the replusive energy between
the nuclei and the energy shift of the frozen orbitals.
"""
driver = PySCFDriver(
atom="Li .0 .0 .0; H .0 .0 " + str(dist),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g',
)
molecule = driver.run()
freeze_list = [0]
remove_list = [-3, -2]
repulsion_energy = molecule.nuclear_repulsion_energy
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
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='parity', threshold=1E-8)
#qubitOp = qubitOp.two_qubit_reduced_operator(num_particles)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
shift = repulsion_energy + energy_shift
return qubitOp, 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
freeze_list = [x % molecule.num_orbitals for x in freeze_list]
# update the idx in remove_list of the idx after frozen, since the idx of orbitals are changed after freezing
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]
# prepare fermionic hamiltonian with orbital freezing and eliminating, and then map to qubit hamiltonian
# and if PARITY mapping is selected, reduction qubits
energy_shift = 0.0
qubit_reduction = True if map_type == 'parity' else False
ferOp = FermionicOperator(h1=h1, h2=h2)
if len(freeze_list) > 0:
ferOp, energy_shift = ferOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)
if len(remove_list) > 0:
ferOp = ferOp.fermion_mode_elimination(remove_list)
num_spin_orbitals -= len(remove_list)
qubitOp = ferOp.mapping(map_type=map_type, threshold=0.00000001)
qubitOp = qubitOp.two_qubit_reduced_operator(
num_particles) if qubit_reduction else qubitOp
qubitOp.chop(10**-10)
#print(qubitOp.print_operators())
print(qubitOp, flush=True)
# setup HartreeFock state
def run_real_qiskit(self):
result = Result()
# ----- Import libraries and initialize -----
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.chemistry import QMolecule, FermionicOperator
from qiskit.chemistry.core import Hamiltonian, TransformationType, QubitMappingType
from qiskit.chemistry.transformations import FermionicTransformation
self.init()
self.driver = PySCFDriver(atom=self.convert_g_to_str(self.g),
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
max_cycle=5000,
max_memory=1024 * 128,
basis='sto3g')
def load_molecule(filename):
if os.path.exists(filename):
print(f"Found {filename}. Loading...")
molecule = QMolecule(filename)
molecule.load()
else:
# Regenerate
print(f"Couldn't find {filename}. Regenerating...")
molecule = self.driver.run()
molecule.save(filename)
return molecule
self.molecule = load_molecule(self.filename)
# ----- Perform test -----
# Build qubit operator (full)
fermop = FermionicOperator(h1=self.molecule.one_body_integrals,
h2=self.molecule.two_body_integrals)
# Freeze
energy_shift = 0
if len(self.freeze_list) > 0:
fermop, energy_shift = fermop.fermion_mode_freezing(
self.freeze_list)
# Rebase remove
remove_list = [
x - np.where(np.array(self.freeze_list) < x)[0].size
for x in self.remove_list
]
# Remove
if len(self.remove_list) > 0:
fermop = fermop.fermion_mode_elimination(remove_list)
result.h1 = fermop.h1
result.h2 = fermop.h2
result.energy_shift = energy_shift
# Generate qubit op
qubitop = fermop.mapping('parity')
#import pdb; pdb.set_trace()
#qubitop = Z2Symmetries.two_qubit_reduction(qubitop, num_particles)
# Generate results
qubit_op_str = qubitop.print_details()
# Write results to file
results_dir = "results/old"
output_file = "qubitop1.txt"
pathlib.Path(results_dir).mkdir(parents=True, exist_ok=True)
with open(os.path.join(results_dir, output_file), "w") as f:
f.write(qubit_op_str)
result.qubitop = qubitop
return result
