Пример #1
0
def ITE_FCI(H_,db,bmax,psi0=None,omega=None):

 Hm    = Hmat(H_)
 N     = Hm.shape[0]
 nbit  = int(np.log2(N))
 eps,U = SciLA.eigh(Hm)
 m0    = np.argmin(eps)
 zeta  = np.exp(-db*(eps-eps[m0]))

 fout = open('ITE_FCI.out','w')
 fout.write("FCI gs energy %.6f \n" % eps[m0])
 fout.write("FCI gs wfn \n")
 print_state(U[:,m0],nbit,fout)

 if(psi0 is None):
  i0          = np.argmin(np.diag(Hm))
  psi_FCI     = np.zeros(N,dtype=complex)
  psi_FCI[i0] = 1.0
 else:
  psi_FCI     = psi0.copy()

 nbeta    = int(bmax/db)+1
 fout.write("FCI ITE\n")
 data = np.zeros((nbeta,2))
 for ib in range(nbeta):
  ea,ev    = Hmoms(H_,psi_FCI)
  #print (ib*db,ea,ev)
  psi_FCI  = np.dot(np.conj(U.T),psi_FCI)
  psi_FCI  = zeta*psi_FCI
  psi_FCI  = np.dot(U,psi_FCI)
  psi_FCI /= LA.norm(psi_FCI)
  if(omega is None): fide = fidelity(psi_FCI,U[:,m0])
  else:              fide = LA.norm(psi_FCI[omega])**2
  fout.write("%.6f %.6f %.6f %.6f \n" % (ib*db,ea,ev,fide))
  #print(ea)
  data[ib, 0] = ib*db
  data[ib, 1] = ea
  if ea < 0.01 and ea > -0.01:
      print('wf: ',psi_FCI)
  # if ea < 1e-3:
  #     print("%.6f %.6f %.6f %.6f \n" % (ib*db,ea,ev,fide))

 fout.write("FCI ITE gs wfn \n")
 #print_state(psi_FCI,nbit,fout)

 fout.close()
 
 return data
Пример #2
0
def QITE(H_, db, bmax, lanczos=False, psi0=None, omega=None, ncheck=1):
    Hm = Hmat(H_)
    N = Hm.shape[0]
    nbit = int(np.log2(N))
    eps, U = SciLA.eigh(Hm)
    m0 = np.argmin(eps)
    zeta = np.exp(-db * (eps - eps[m0]))
    fide = 1.0

    fout = open('QITE.out', 'w')
    fout.write("FCI gs energy %.6f \n" % eps[m0])
    fout.write("FCI gs wfn \n")
    print_state(U[:, m0], nbit, fout)

    psi_QITE = psi0[:]

    nbeta = int(bmax / db) + 1
    hvect_LANZ = np.zeros(nbeta + 1)
    svect_LANZ = np.zeros(nbeta + 1)

    xv = None
    fout.write("QITE\n")
    for ib in range(nbeta):
        ea, ev = Hmoms(H_, psi_QITE)
        hvect_LANZ[ib] = ea

        if (omega is None): fide = fidelity(psi_QITE, U[:, m0])
        else: fide = LA.norm(psi_QITE[omega])**2

        if (lanczos):
            ea_ = Lanczos_QITE(hvect_LANZ[:ib + 1], svect_LANZ[:ib + 1], db)
            fout.write("%.6f %.6f %.6f %.6f %.6f \n" %
                       (ib * db, ea, ev, fide, ea_))
        else:
            fout.write("%.6f %.6f %.6f %.6f \n" % (ib * db, ea, ev, fide))
        fout.flush()

        psi_QITE, dnorm, xv = QITE_step(H_, psi_QITE, db, xv, ib % ncheck == 0)
        svect_LANZ[ib + 1] = svect_LANZ[ib] + np.log(dnorm)

    fout.write("QITE gs wfn \n")
    print_state(psi_QITE, nbit, fout)
    dump_state(psi_QITE, nbit, 'qite.psi')
    dump_lanz_vecs(hvect_LANZ[:nbeta], svect_LANZ[:nbeta], 'qlanz.vecs')

    fout.close()
Пример #3
0
R     = 1.50
db    = 0.01
bmax  =  8.00

vrtex = [x for x in range(nspin)]
if(nspin==4): np.random.seed(1953)
else:         np.random.seed(14657)
links = []
for i in range(nspin):
 for j in range(i+1,nspin):
  x = np.random.randint(2,size=1)[0]
  if(x==1): links.append((i,j))

#if(nspin==4): links=[(0,1),(0,2),(0,3),(1,3),(2,3)] # IBM graph

gamma = (vrtex,links)

H  = MaxCut(gamma,R)
print_Hamiltonian(H)
Hm = np.diag(Hmat(H))
E0 = np.min(Hm)
omega = np.where(np.abs(Hm-E0)<1e-6)[0]

theta0    = np.random.random()*2.0*np.pi
theta1,e1 = hom_mf_solution(theta0,nspin,H)
psi_1     = hom_mf_state(theta1,nspin)
print "HOM mf-energy ",e1

ITE_FCI(H,db,bmax,psi0=psi_1,omega=omega)
QITE(H,db,bmax,lanczos=False,psi0=psi_1,omega=omega,ncheck=10)
Пример #4
0
from scipy.linalg import eigh
nspin =  3

R     =  0.5
db    =  0.5
bmax  =  2.00

#H = Heisenberg_LR(nspin,R)
J = 1/np.sqrt(2)
#H = TransverseIsing(nspin, R, J, J)
#H = Ising(nspin, R, pi/2)
H = single_qubit_field(pi/4)
#print('Hamiltonian\n',H)
print_Hamiltonian(H)

Hm = Hmat(H)
evl, evc = eigh(Hm)
print(evl)
# print()
# print(np.real(Hm))


# AFM initial guess

psi_0       = np.zeros(2**nspin,dtype=complex)
#psi_0       = np.array([ 0, 0,0,1],dtype=complex)
#print(psi_0)
xvec        = [0,1]*ceil((nspin/2))
xind        = Bas2Int(xvec,2)
#psi_0[xind] = 1.0
psi_0[0] = 1.0
Пример #5
0
def QITE(H_, db, bmax, lanczos=False, psi0=None, omega=None, ncheck=1):

    Hm = Hmat(H_)
    N = Hm.shape[0]
    nbit = int(np.log2(N))
    eps, U = SciLA.eigh(Hm)
    m0 = np.argmin(eps)
    epsm0 = eps[m0]
    Um0 = U[:, m0]
    zeta = np.exp(-db * (eps - eps[m0]))
    fide = 1.0

    fout = open('QITE.out', 'w')
    fout.write("FCI gs energy %.6f \n" % epsm0)
    fout.write("FCI gs wfn \n")
    print_state(Um0, nbit, fout)

    psi_QITE = psi0[:]

    nbeta = int(bmax / db) + 1
    hvect_LANZ = np.zeros(nbeta + 1)
    svect_LANZ = np.zeros(nbeta + 1)

    xv = None
    hpauli = {}
    fout.write("QITE\n")
    data = np.zeros((nbeta, 2))
    for ib in range(nbeta):
        print('B: ', ib * db)
        ea, ev = Hmoms(H_, psi_QITE)
        print('Energy: ', ea)
        hvect_LANZ[ib] = ea

        if (omega is None):
            fide = fidelity(psi_QITE, Um0)
        else:
            fide = LA.norm(psi_QITE[omega])**2

        if (lanczos):
            ea_ = Lanczos_QITE(hvect_LANZ[:ib + 1], svect_LANZ[:ib + 1], db)
            fout.write("%.6f %.6f %.6f %.6f %.6f \n" %
                       (ib * db, ea, ev, fide, ea_))
        else:
            fout.write("%.6f %.6f %.6f %.6f \n" % (ib * db, ea, ev, fide))
            #print("%.6f %.6f %.6f %.6f \n" % (ib*db,ea,ev,fide))
        fout.flush()

        b = ib * db
        data[ib, 0] = b
        data[ib, 1] = ea
        if (ncheck > 0):
            check = (ib % ncheck == 0)
        else:
            check = False
        psi_QITE, dnorm, xv, Xop = QITE_step(H_, psi_QITE, db, xv, check)
        hpauli[b] = Xop
        # Feedback portion
        # Number of applications of the unitary to get ground state

        svect_LANZ[ib + 1] = svect_LANZ[ib] + np.log(dnorm)

    fout.write("QITE gs wfn \n")
    print_state(psi_QITE, nbit, fout)
    dump_state(psi_QITE, nbit, 'qite.psi')
    dump_lanz_vecs(hvect_LANZ[:nbeta], svect_LANZ[:nbeta], 'qlanz.vecs')

    fout.close()

    return data, hpauli
Пример #6
0
def QITE(H_,
         db,
         bmax,
         lanczos=False,
         psi0=None,
         omega=None,
         ncheck=1,
         davidson=True):

    if (davidson):
        N = H_[0][2].shape[1]
        nbit = int(np.log2(N))
        hdiag = np.zeros(N, dtype=complex)
        for i in range(N):
            hdiag[i] = Hii(H_, i)
            print i, hdiag[i]

        precond = lambda x, e, *args: x / (hdiag - e + 1e-4)

        def hop(c_):
            return Hpsi(H_, c_)

        if (psi0 is None):
            i0 = np.argmin(hdiag)
            psi0 = np.zeros(N, dtype=complex)
            psi0[i0] = 1.0

        from pyscf.lib import davidson
        epsm0, Um0 = davidson(hop, psi0, precond)
    else:
        Hm = Hmat(H_)
        N = Hm.shape[0]
        nbit = int(np.log2(N))
        eps, U = SciLA.eigh(Hm)
        m0 = np.argmin(eps)
        epsm0 = eps[m0]
        Um0 = U[:, m0]
        zeta = np.exp(-db * (eps - eps[m0]))
        fide = 1.0

    fout = open('QITE.out', 'w')
    fout.write("FCI gs energy %.6f \n" % epsm0)
    fout.write("FCI gs wfn \n")
    print_state(Um0, nbit, fout)

    psi_QITE = psi0[:]

    nbeta = int(bmax / db) + 1
    hvect_LANZ = np.zeros(nbeta + 1)
    svect_LANZ = np.zeros(nbeta + 1)

    xv = None
    fout.write("QITE\n")
    for ib in range(nbeta):
        ea, ev = Hmoms(H_, psi_QITE)
        hvect_LANZ[ib] = ea

        if (omega is None): fide = fidelity(psi_QITE, Um0)
        else: fide = LA.norm(psi_QITE[omega])**2

        if (lanczos):
            ea_ = Lanczos_QITE(hvect_LANZ[:ib + 1], svect_LANZ[:ib + 1], db)
            fout.write("%.6f %.6f %.6f %.6f %.6f \n" %
                       (ib * db, ea, ev, fide, ea_))
        else:
            fout.write("%.6f %.6f %.6f %.6f \n" % (ib * db, ea, ev, fide))
        fout.flush()

        if (ncheck > 0): check = (ib % ncheck == 0)
        else: check = False
        psi_QITE, dnorm, xv = QITE_step(H_, psi_QITE, db, xv, check)
        svect_LANZ[ib + 1] = svect_LANZ[ib] + np.log(dnorm)

    fout.write("QITE gs wfn \n")
    print_state(psi_QITE, nbit, fout)
    dump_state(psi_QITE, nbit, 'qite.psi')
    dump_lanz_vecs(hvect_LANZ[:nbeta], svect_LANZ[:nbeta], 'qlanz.vecs')

    fout.close()