def test_h2_one_qubit_qasm(self):
"""Test H2 with tapering and qasm backend"""
two_qubit_reduction = True
qubit_mapping = 'parity'
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(self.molecule)
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
# tapering
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
# know the sector
tapered_op = z2_symmetries.taper(qubit_op)[1]
var_form = RY(tapered_op.num_qubits, depth=1)
optimizer = SPSA(max_trials=50)
eom_vqe = QEomVQE(tapered_op, var_form, optimizer, num_orbitals=num_orbitals,
num_particles=num_particles, qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=tapered_op.z2_symmetries, untapered_op=qubit_op)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=65536)
result = eom_vqe.run(quantum_instance)
np.testing.assert_array_almost_equal(self.reference, result['energies'], decimal=2)
def test_h2_one_qubit(self):
"""Test H2 with tapering."""
two_qubit_reduction = False
qubit_mapping = 'jordan_wigner'
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(self.molecule)
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
tapered_op = z2_symmetries.taper(qubit_op)[5]
eom_ee = QEomEE(tapered_op,
num_orbitals=num_orbitals,
num_particles=num_particles,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=tapered_op.z2_symmetries,
untapered_op=qubit_op)
result = eom_ee.run()
np.testing.assert_array_almost_equal(self.reference,
result['energies'])
def _process_z2symmetry_reduction(self, qubit_op, aux_ops):
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
if z2_symmetries.is_empty():
logger.debug('No Z2 symmetries found')
z2_qubit_op = qubit_op
z2_aux_ops = aux_ops
z2_symmetries = Z2Symmetries([], [], [], None)
else:
logger.debug('%s Z2 symmetries found: %s', len(z2_symmetries.symmetries),
','.join([symm.to_label() for symm in z2_symmetries.symmetries]))
# Check auxiliary operators commute with main operator's symmetry
logger.debug('Checking operators commute with symmetry:')
symmetry_ops = []
for symmetry in z2_symmetries.symmetries:
symmetry_ops.append(WeightedPauliOperator(paulis=[[1.0, symmetry]]))
commutes = Hamiltonian._check_commutes(symmetry_ops, qubit_op)
if not commutes:
raise QiskitChemistryError('Z2 symmetry failure main operator must commute '
'with symmetries found from it')
for i, aux_op in enumerate(aux_ops):
commutes = Hamiltonian._check_commutes(symmetry_ops, aux_op)
if not commutes:
aux_ops[i] = None # Discard since no meaningful measurement can be done
if self._z2symmetry_reduction == 'auto':
hf_state = HartreeFock(num_orbitals=self._molecule_info[self.INFO_NUM_ORBITALS],
qubit_mapping=self._qubit_mapping,
two_qubit_reduction=self._two_qubit_reduction,
num_particles=self._molecule_info[self.INFO_NUM_PARTICLES])
z2_symmetries = Hamiltonian._pick_sector(z2_symmetries, hf_state.bitstr)
else:
if len(self._z2symmetry_reduction) != len(z2_symmetries.symmetries):
raise QiskitChemistryError('z2symmetry_reduction tapering values list has '
'invalid length {} should be {}'.
format(len(self._z2symmetry_reduction),
len(z2_symmetries.symmetries)))
valid = np.all(np.isin(self._z2symmetry_reduction, [-1, 1]))
if not valid:
raise QiskitChemistryError('z2symmetry_reduction tapering values list must '
'contain -1\'s and/or 1\'s only was {}'.
format(self._z2symmetry_reduction,))
z2_symmetries.tapering_values = self._z2symmetry_reduction
logger.debug('Apply symmetry with tapering values %s', z2_symmetries.tapering_values)
chop_to = 0.00000001 # Use same threshold as qubit mapping to chop tapered operator
z2_qubit_op = z2_symmetries.taper(qubit_op).chop(chop_to)
z2_aux_ops = []
for aux_op in aux_ops:
z2_aux_ops.append(z2_symmetries.taper(aux_op).chop(chop_to) if aux_op is not None
else None)
return z2_qubit_op, z2_aux_ops, z2_symmetries
def setUp(self):
super().setUp()
try:
self.molecule = "H 0.000000 0.000000 0.735000;H 0.000000 0.000000 0.000000"
self.driver = PySCFDriver(atom=self.molecule,
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='631g')
self.qmolecule = self.driver.run()
self.core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[])
self.qubit_op, _ = self.core.run(self.qmolecule)
z2_symmetries = Z2Symmetries.find_Z2_symmetries(self.qubit_op)
tapered_ops = z2_symmetries.taper(self.qubit_op)
smallest_eig_value = 99999999999999
smallest_idx = -1
for idx, _ in enumerate(tapered_ops):
ee = ExactEigensolver(tapered_ops[idx], k=1)
curr_value = ee.run()['energy']
if curr_value < smallest_eig_value:
smallest_eig_value = curr_value
smallest_idx = idx
self.the_tapered_op = tapered_ops[smallest_idx]
self.reference_energy_pUCCD = -1.1434447924298028
self.reference_energy_UCCD0 = -1.1476045878481704
self.reference_energy_UCCD0full = -1.1515491334334347
# reference energy of UCCSD/VQE with tapering everywhere
self.reference_energy_UCCSD = -1.1516142309717594
# reference energy of UCCSD/VQE when no tapering on excitations is used
self.reference_energy_UCCSD_no_tap_exc = -1.1516142309717594
# excitations for succ
self.reference_singlet_double_excitations = [[0, 1, 4, 5],
[0, 1, 4, 6],
[0, 1, 4, 7],
[0, 2, 4, 6],
[0, 2, 4, 7],
[0, 3, 4, 7]]
# groups for succ_full
self.reference_singlet_groups = [[[0, 1, 4, 5]],
[[0, 1, 4, 6], [0, 2, 4, 5]],
[[0, 1, 4, 7], [0, 3, 4, 5]],
[[0, 2, 4, 6]],
[[0, 2, 4, 7], [0, 3, 4, 6]],
[[0, 3, 4, 7]]]
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
def test_h2_one_qubit_statevector(self):
"""Test H2 with tapering and statevector backend."""
two_qubit_reduction = True
qubit_mapping = 'parity'
warnings.filterwarnings('ignore', category=DeprecationWarning)
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
warnings.filterwarnings('always', category=DeprecationWarning)
qubit_op, _ = core.run(self.molecule)
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
# tapering
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
# know the sector
tapered_op = z2_symmetries.taper(qubit_op)[1]
initial_state = HartreeFock(num_orbitals=num_orbitals,
num_particles=num_particles,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
sq_list=tapered_op.z2_symmetries.sq_list)
var_form = UCCSD(num_orbitals=num_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=tapered_op.z2_symmetries)
optimizer = SPSA(maxiter=50)
eom_vqe = QEomVQE(tapered_op,
var_form,
optimizer,
num_orbitals=num_orbitals,
num_particles=num_particles,
qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction,
z2_symmetries=tapered_op.z2_symmetries,
untapered_op=qubit_op)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend)
result = eom_vqe.run(quantum_instance)
np.testing.assert_array_almost_equal(self.reference,
result['energies'],
decimal=5)
def setUp(self):
super().setUp()
try:
driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0 1.6',
unit=UnitsType.ANGSTROM,
charge=0,
spin=0,
basis='sto3g')
except QiskitChemistryError:
self.skipTest('PYSCF driver does not appear to be installed')
self.qmolecule = driver.run()
self.core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[])
self.qubit_op, _ = self.core.run(self.qmolecule)
self.z2_symmetries = Z2Symmetries.find_Z2_symmetries(self.qubit_op)
self.reference_energy = -7.882096489442
def _process_z2symmetry_reduction(
self, qubit_op: WeightedPauliOperator,
aux_ops: List[WeightedPauliOperator]) -> Tuple:
"""
Implement z2 symmetries in the qubit operator
Args:
qubit_op : qubit operator
aux_ops: auxiliary operators
Returns:
(z2_qubit_op, z2_aux_ops, z2_symmetries)
Raises:
QiskitChemistryError: Invalid input
"""
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
if z2_symmetries.is_empty():
logger.debug('No Z2 symmetries found')
z2_qubit_op = qubit_op
z2_aux_ops = aux_ops
z2_symmetries = Z2Symmetries([], [], [], None)
else:
logger.debug(
'%s Z2 symmetries found: %s', len(z2_symmetries.symmetries),
','.join(
[symm.to_label() for symm in z2_symmetries.symmetries]))
# Check auxiliary operators commute with main operator's symmetry
logger.debug('Checking operators commute with symmetry:')
symmetry_ops = []
for symmetry in z2_symmetries.symmetries:
symmetry_ops.append(
WeightedPauliOperator(paulis=[[1.0, symmetry]]))
commutes = FermionicTransformation._check_commutes(
symmetry_ops, qubit_op)
if not commutes:
raise QiskitChemistryError(
'Z2 symmetry failure main operator must commute '
'with symmetries found from it')
for i, aux_op in enumerate(aux_ops):
commutes = FermionicTransformation._check_commutes(
symmetry_ops, aux_op)
if not commutes:
aux_ops[
i] = None # Discard since no meaningful measurement can be done
if self._z2symmetry_reduction == 'auto':
from ..circuit.library.initial_states.hartree_fock import hartree_fock_bitstring
hf_bitstr = hartree_fock_bitstring(
num_orbitals=self._molecule_info['num_orbitals'],
qubit_mapping=self._qubit_mapping,
two_qubit_reduction=self._two_qubit_reduction,
num_particles=self._molecule_info['num_particles'])
z2_symmetries = FermionicTransformation._pick_sector(
z2_symmetries, hf_bitstr)
else:
if len(self._z2symmetry_reduction) != len(
z2_symmetries.symmetries):
raise QiskitChemistryError(
'z2symmetry_reduction tapering values list has '
'invalid length {} should be {}'.format(
len(self._z2symmetry_reduction),
len(z2_symmetries.symmetries)))
valid = np.all(np.isin(self._z2symmetry_reduction, [-1, 1]))
if not valid:
raise QiskitChemistryError(
'z2symmetry_reduction tapering values list must '
'contain -1\'s and/or 1\'s only was {}'.format(
self._z2symmetry_reduction, ))
z2_symmetries.tapering_values = self._z2symmetry_reduction
logger.debug('Apply symmetry with tapering values %s',
z2_symmetries.tapering_values)
chop_to = 0.00000001 # Use same threshold as qubit mapping to chop tapered operator
z2_qubit_op = z2_symmetries.taper(qubit_op).chop(chop_to)
z2_aux_ops = []
for aux_op in aux_ops:
if aux_op is None:
z2_aux_ops += [None]
else:
z2_aux_ops += [z2_symmetries.taper(aux_op).chop(chop_to)]
return z2_qubit_op, z2_aux_ops, z2_symmetries
def taper(molecule, core, qubit_op, A_op, outf):
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
the_ancillas = A_op
nsym = len(z2_symmetries.sq_paulis)
the_tapered_op = qubit_op
sqlist = None
z2syms = None
outf.write('\n\nstart tapering... \n\n')
if (nsym > 0):
outf.write('Z2 symmetries found:\n')
for symm in z2_symmetries.symmetries:
outf.write(symm.to_label() + '\n')
outf.write('single qubit operators found:\n')
for sq in z2_symmetries.sq_paulis:
outf.write(sq.to_label() + '\n')
outf.write('cliffords found:\n')
for clifford in z2_symmetries.cliffords:
outf.write(clifford.print_details() + '\n')
outf.write('single-qubit list: {}\n'.format(z2_symmetries.sq_list))
tapered_ops = z2_symmetries.taper(qubit_op)
for tapered_op in tapered_ops:
outf.write(
"Number of qubits of tapered qubit operator: {}\n".format(
tapered_op.num_qubits))
ee = NumPyEigensolver(qubit_op, k=1)
result = core.process_algorithm_result(ee.run())
for line in result[0]:
outf.write(line + '\n')
smallest_eig_value = 99999999999999
smallest_idx = -1
for idx in range(len(tapered_ops)):
ee = NumPyEigensolver(tapered_ops[idx], k=1)
curr_value = ee.run()['eigenvalues'][0]
if curr_value < smallest_eig_value:
smallest_eig_value = curr_value
smallest_idx = idx
outf.write(
"Lowest eigenvalue of the {}-th tapered operator (computed part) is {:.12f}\n"
.format(idx, curr_value))
the_tapered_op = tapered_ops[smallest_idx]
the_coeff = tapered_ops[smallest_idx].z2_symmetries.tapering_values
outf.write(
"The {}-th tapered operator matches original ground state energy, with corresponding symmetry sector of {}\n"
.format(smallest_idx, the_coeff))
sqlist = the_tapered_op.z2_symmetries.sq_list
z2syms = the_tapered_op.z2_symmetries
the_ancillas = []
for A in A_op:
A_taper = z2_symmetries.taper(A)
if (type(A_taper) == list):
the_ancillas.append(A_taper[smallest_idx])
else:
the_ancillas.append(A_taper)
outf.write('\n\n...finish tapering \n\n')
return the_tapered_op, the_ancillas, z2syms, sqlist
def run_ucc_r12(opt):
"""
Parameters
----------
* opt dictionary with user and default options/thresholds
Returns
-------
* UCC-R12 ground state energy
"""
import itertools
import logging
import numpy as np
import time
from datetime import datetime
import qiskit
from qiskit import BasicAer,Aer
from qiskit.aqua import set_qiskit_aqua_logging, QuantumInstance
from qiskit.aqua.operators import Z2Symmetries, WeightedPauliOperator
from qiskit.aqua.algorithms.adaptive import VQE
from qiskit.aqua.algorithms.classical import ExactEigensolver
from qiskit.aqua.components.optimizers import L_BFGS_B,CG,SPSA,SLSQP, COBYLA
from qiskit.chemistry.drivers import PySCFDriver, UnitsType, HFMethodType
from qiskit.chemistry.core import TransformationType, QubitMappingType
from qiskit.chemistry.aqua_extensions.components.initial_states import HartreeFock
from qiskit.chemistry import set_qiskit_chemistry_logging
# ----- local functions ----- #
import sys
sys.path.append('/Users/mario/Documents/GitHub/R12-F12/project_ec/ucc_ec/')
from qmolecule_ec import QMolecule_ec,build_parameter_list
from hamiltonian_ec import Hamiltonian
from uccsd_ec import UCCSD
from davidson import davidson
#import logging
#set_qiskit_chemistry_logging(logging.DEBUG)
logfile = open(opt["logfile"],'w')
dateTimeObj = datetime.now()
logfile.write("date and time "+str(dateTimeObj)+"\n")
logfile.write("\n\n")
import subprocess
label = subprocess.check_output(['git','log','-1','--format="%H"']).strip()
logfile.write("git commit "+str(label)+"\n")
logfile.write("\n\n")
qiskit_dict = qiskit.__qiskit_version__
logfile.write("qiskit version \n")
for k in qiskit_dict:
logfile.write(k+" : "+qiskit_dict[k]+"\n")
logfile.write("\n\n")
logfile.write("local run options \n")
for k in opt:
logfile.write(k+" : "+str(opt[k])+"\n")
logfile.write("\n\n")
import time
t0 = time.time()
if(opt["input_file"] is None):
# ----- normal molecular calc ----- #
if(opt["calc_type"].lower() == "rhf"): hf=HFMethodType.RHF
if(opt["calc_type"].lower() == "rohf"): hf=HFMethodType.ROHF
if(opt["calc_type"].lower() == "uhf"): hf=HFMethodType.UHF
driver = PySCFDriver(atom=opt["geometry"],unit=UnitsType.ANGSTROM,charge=opt["charge"],spin=opt["spin"],basis=opt["basis"],hf_method=hf)
molecule = driver.run()
molecule_ec = QMolecule_ec(molecule=molecule,filename=None,logfile=logfile)
else:
# ----- custom matrix elements ----- #
molecule_ec = QMolecule_ec(molecule=None,filename=opt["input_file"],calc=opt["calc_type"],nfreeze=opt["nfreeze"],logfile=logfile)
molecule_ec.mo_eri_ints_ec = (molecule_ec.mo_eri_ints_ec).transpose((0,1,3,2))
t1 = time.time()
logfile.write("classical ES and setup: %f [s] \n" % (t1-t0))
logfile.write("\n\n")
core = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,two_qubit_reduction=True,freeze_core=False)
qubit_op, _ = core.run(molecule_ec)
t2 = time.time()
logfile.write("second-quantized Hamiltonian setup : %f [s] \n" % (t2-t1))
logfile.write("\n\n")
logfile.write("Original number of qubits %d \n" % (qubit_op.num_qubits))
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
nsym = len(z2_symmetries.sq_paulis)
the_tapered_op = qubit_op
sqlist = None
z2syms = None
if(nsym>0):
logfile.write('\nZ2 symmetries found: \n')
for symm in z2_symmetries.symmetries:
logfile.write(symm.to_label())
logfile.write('\nsingle-qubit operators found: \n')
for sq in z2_symmetries.sq_paulis:
logfile.write(sq.to_label())
logfile.write('\nCliffords found: \n')
for clifford in z2_symmetries.cliffords:
logfile.write(clifford.print_details())
logfile.write('\nsingle-qubit list: {} \n'.format(z2_symmetries.sq_list))
tapered_ops = z2_symmetries.taper(qubit_op)
for tapered_op in tapered_ops:
logfile.write("Number of qubits of tapered qubit operator: %d \n" % (tapered_op.num_qubits))
t3 = time.time()
logfile.write("detection of symmetries: %f [s] \n" % (t3-t2))
smallest_eig_value = 99999999999999
smallest_idx = -1
for idx in range(len(tapered_ops)):
td0 = time.time()
from utils import retrieve_SCF_energy
print("In sector ",idx,len(tapered_ops))
curr_value = retrieve_SCF_energy(tapered_ops[idx].copy(),core,opt) #,parm_list)
curr_value = np.abs(curr_value-molecule_ec.hf_energy)
print("Deviation ",curr_value)
if curr_value < smallest_eig_value:
smallest_eig_value = curr_value
smallest_idx = idx
if(curr_value<1e-6): break
td1 = time.time()
val = curr_value
logfile.write("Lowest-energy computational basis state of the {}-th tapered operator is %s %f \n" % (str(idx),val))
logfile.write("HF search time %f: \n" % (td1-td0))
the_tapered_op = tapered_ops[smallest_idx]
the_coeff = tapered_ops[smallest_idx].z2_symmetries.tapering_values
logfile.write("{}-th tapered operator, with corresponding symmetry sector of {}".format(smallest_idx, the_coeff))
logfile.write("\nNumber of qubits in the {}-th tapered operator {}\n\n".format(smallest_idx,the_tapered_op.num_qubits))
sqlist = the_tapered_op.z2_symmetries.sq_list
z2syms = the_tapered_op.z2_symmetries
# ========
# setup initial state
# ========
init_state = HartreeFock(num_qubits=the_tapered_op.num_qubits, num_orbitals=core._molecule_info['num_orbitals'],
qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction,
num_particles=core._molecule_info['num_particles'],sq_list=sqlist)
# ---- initial parameter guess
init_parm = None
if(opt["start_pt"].lower()=="file"):
init_parm = np.loadtxt('vqe.parameters')
if(opt["var_form"].lower()=="uccsd" and opt["start_pt"].lower()=="ccsd"):
parm_list = build_parameter_list(molecule_ec)
logfile.write("Initial parameters = %d\n" % len(parm_list))
for mu,p in enumerate(parm_list):
logfile.write('%d %f\n' % (mu,p))
if(opt["var_form"].lower()=="uccsd"):
var_form = UCCSD(num_qubits=the_tapered_op.num_qubits,depth=opt["UCCSD_depth"],
num_orbitals=core._molecule_info['num_orbitals'],
num_particles=core._molecule_info['num_particles'],
active_occupied=opt["UCCSD_active_occupied"], active_unoccupied=opt["UCCSD_active_unoccupied"], initial_state=init_state,
qubit_mapping=core._qubit_mapping, two_qubit_reduction=core._two_qubit_reduction,
num_time_slices=opt["UCCSD_num_time_slices"],z2_symmetries=z2syms,init_parm=parm_list)
if(opt["var_form"].lower()=="uccsd" and opt["start_pt"].lower()=="ccsd"):
nparm,ndepth = len(var_form._mask),var_form._depth
init_parm = np.zeros(nparm*ndepth)
for idp in range(ndepth):
for ims in range(nparm):
init_parm[ims+idp*nparm] = parm_list[var_form._mask[ims]]
logfile.write("Selected parameters = %d\n" % nparm)
for mu,p in enumerate(var_form._mask):
logfile.write('%d %f\n' % (p,parm_list[p]))
elif(opt["var_form"].lower()=="ry"):
var_form = RY(the_tapered_op.num_qubits,depth=opt["R_depth"],
entanglement=opt["R_entanglement"],initial_state=HF_state)
elif(opt["var_form"].lower()=="ryrz"):
var_form = RYRZ(the_tapered_op.num_qubits,depth=opt["R_depth"],
entanglement=opt["R_entanglement"],initial_state=HF_state)
elif(opt["var_form"].lower()=="swaprz"):
var_form = SwapRZ(the_tapered_op.num_qubits,depth=opt["R_depth"],
entanglement=opt["R_entanglement"],initial_state=HF_state)
else:
print("invalid variational form")
assert(False)
# setup optimizer
if( opt["optimizer"].lower()=="bfgs"): optimizer = L_BFGS_B(maxiter=opt["max_eval"])
elif(opt["optimizer"].lower()=="cg"): optimizer = CG(maxiter=opt["max_eval"])
elif(opt["optimizer"].lower()=="slsqp"): optimizer = SLSQP(maxiter=opt["max_eval"])
elif(opt["optimizer"].lower()=="spsa"): optimizer = SPSA()
elif(opt["optimizer"].lower()=="cobyla"): optimizer = COBYLA(maxiter=opt["max_eval"])
else: print("not coded yet"); assert(False)
# set vqe
if(opt["var_form"].lower()=="uccsd"): algo = VQE(the_tapered_op,var_form,optimizer,initial_point=init_parm)
else: algo = VQE(the_tapered_op,var_form,optimizer)
# setup backend
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend)
t0 = time.time()
algo_result = algo.run(quantum_instance)
t1 = time.time()
logfile.write("\nVQE time [s] %f \n\n" % (t1-t0))
result = core.process_algorithm_result(algo_result)
for line in result[0]:
logfile.write(line+"\n")
logfile.write("\nThe parameters for UCCSD are:\n")
for i,(tc,tq) in enumerate(zip(init_parm,algo_result['opt_params'])):
logfile.write("%d %f %f \n" % (i,tc,tq))
if(opt["print_parameters"]):
par_file = open('vqe.parameters','w')
for p in algo_result['opt_params']:
par_file.write("%f \n" % p)
par_file.close()
#td0 = time.time()
#ee = davidson(the_tapered_op,'fci')
#td1 = time.time()
#logfile.write("\n\nExact diagonalization, energy: %f \n" % (ee+molecule_ec.nuclear_repulsion_energy+molecule_ec.energy_offset_ec))
#logfile.write("Davidson FCI time: %f [s] \n" % (td1-td0))
print('============================================================================')
print(' DONE!')
print('============================================================================')
return 0
basis='sto3g')
# basis='sto6g')
# basis='631g')
qmolecule = driver.run()
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=False,
orbital_reduction=[])
qubit_op, _ = core.run(qmolecule)
# find the symmetries of the Hamiltonian
z2_symmetries = Z2Symmetries.find_Z2_symmetries(qubit_op)
tapered_ops = z2_symmetries.taper(qubit_op)
smallest_idx = 0
# Prior knowledge of which tapered_op has ground state
# or you can find the operator that has the ground state by diagonalising each operator
#smallest_eig_value = 99999999999999
#smallest_idx = -1
#for idx in range(len(tapered_ops)):
# print('operator number: ', idx)
# ee = ExactEigensolver(tapered_ops[idx], k=1)
# curr_value = ee.run()['energy']
# if curr_value < smallest_eig_value:
# smallest_eig_value = curr_value
# smallest_idx = idx
#print('Operator number: ', smallest_idx, ' contains the ground state.')
