def check_pz(L, dtype, Nup=None): L_2 = int(L / 2) hr = [(i + 0.1) ** 2 / float(L ** 2) for i in range(L_2)] hi = [-(i + 0.1) ** 2 / float(L ** 2) for i in range(L_2)] hi.reverse() hi.extend(hr) h = [[hi[i], i] for i in range(L)] J = [[1.0, i, (i + 1) % L] for i in range(L - 1)] static = [["zz", J], ["yy", J], ["xx", J], ["z", h]] H = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype) Ns = H.Ns E = H.eigvalsh() H1 = hamiltonian(static, [], N=L, Nup=Nup, pzblock=1, dtype=dtype) H2 = hamiltonian(static, [], N=L, Nup=Nup, pzblock=-1, dtype=dtype) E1 = H1.eigvalsh() E2 = H2.eigvalsh() Epz = np.concatenate((E1, E2)) Epz.sort() if norm(Epz - E) > Ns * eps(dtype): raise Exception( "test failed pz symmetry at L={0:3d} with dtype {1} and Nup={2:2d} {3}".format( L, np.dtype(dtype), Nup, norm(Epz - E) ) )
def compare_hamiltonian(basis_1, basis_2, ratio_12, test_ratio=True): pm_1 = hamiltonian(opstr_pm, [], basis=basis_1, **no_checks).toarray() mp_1 = hamiltonian(opstr_mp, [], basis=basis_1, **no_checks).toarray() xx_1 = hamiltonian(opstr_xx, [], basis=basis_1, **no_checks).toarray() yy_1 = hamiltonian(opstr_yy, [], basis=basis_1, **no_checks).toarray() zz_1 = hamiltonian(opstr_zz, [], basis=basis_1, **no_checks).toarray() pm_2 = hamiltonian(opstr_pm, [], basis=basis_2, **no_checks).toarray() mp_2 = hamiltonian(opstr_mp, [], basis=basis_2, **no_checks).toarray() xx_2 = hamiltonian(opstr_xx, [], basis=basis_2, **no_checks).toarray() yy_2 = hamiltonian(opstr_yy, [], basis=basis_2, **no_checks).toarray() zz_2 = hamiltonian(opstr_zz, [], basis=basis_2, **no_checks).toarray() if test_ratio: np.testing.assert_allclose(pm_1, ratio_12 * pm_2, atol=1e-13) np.testing.assert_allclose(mp_1, ratio_12 * mp_2, atol=1e-13) else: np.testing.assert_allclose(pm_1, ratio_12 * pm_2, atol=1e-13) np.testing.assert_allclose(mp_1, ratio_12 * mp_2, atol=1e-13) np.testing.assert_allclose(xx_1, ratio_12 * xx_2, atol=1e-13) np.testing.assert_allclose(yy_1, ratio_12 * yy_2, atol=1e-13) np.testing.assert_allclose(zz_1, ratio_12 * zz_2, atol=1e-13)
def check_t_z(L, dtype, Nup=None): hx = random() J = random() h = [[hx, i] for i in range(L)] J1 = [[J, i, (i + 1) % L] for i in range(L)] if type(Nup) is int: static = [["zz", J1], ["yy", J1], ["xx", J1]] else: static = [["zz", J1], ["x", h]] L_2 = int(L / 2) for kblock in range(-L_2 + 1, L_2 + 1): Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, zblock=+1) Hk2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, zblock=-1) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() Ekz = np.append(Ek1, Ek2) Ekz.sort() if norm(Ek - Ekz) > Ns * eps(dtype): raise Exception( "test failed t z symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format( L, np.dtype(dtype), Nup, norm(Ek - Ekz) ) )
def check_p_z(L, dtype, Nup=None): h = [[1.0, i] for i in range(L)] J = [[1.0, i, (i + 1) % L] for i in range(L - 1)] if type(Nup) is int: static = [["zz", J], ["yy", J], ["xx", J]] else: static = [["zz", J], ["x", h]] H = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype) Ns = H.Ns E = H.eigvalsh() H1 = hamiltonian(static, [], N=L, Nup=Nup, pblock=1, zblock=1, dtype=dtype) H2 = hamiltonian(static, [], N=L, Nup=Nup, pblock=-1, zblock=1, dtype=dtype) H3 = hamiltonian(static, [], N=L, Nup=Nup, pblock=1, zblock=-1, dtype=dtype) H4 = hamiltonian(static, [], N=L, Nup=Nup, pblock=-1, zblock=-1, dtype=dtype) E1 = H1.eigvalsh() E2 = H2.eigvalsh() E3 = H3.eigvalsh() E4 = H4.eigvalsh() Epz = np.concatenate((E1, E2, E3, E4)) Epz.sort() if norm(Epz - E) > Ns * eps(dtype): raise Exception( "test failed p z symmetry at L={0:3d} with dtype {1} and Nup {2:2d} {3}".format( L, np.dtype(dtype), Nup, norm(Epz - E) ) )
def check_t(L, dtype, Nup=None): hx = random() J = random() h = [[hx, i] for i in range(L)] J1 = [[J, i, (i + 1) % L] for i in range(L)] if type(Nup) is int: static = [["zz", J1], ["yy", J1], ["xx", J1]] else: static = [["zz", J1], ["x", h]] H = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype) Ns = H.Ns E = H.eigvalsh() Et = np.array([]) for kblock in range(0, L): Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock) Et = np.append(Et, Hk.eigvalsh()) Et.sort() if norm(Et - E) > Ns * eps(dtype): raise Exception( "test failed t symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format( L, np.dtype(dtype), Nup, norm(Et - E) ) )
def get_operators(L): if L % 2 == 1: S = "{}/2".format(L) else: S = "{}".format(L // 2) spin_basis = spin_basis_1d(L, pauli=True, kblock=0, pblock=1) bath_basis = spin_basis_1d(1, S=S) basis = tensor_basis(spin_basis, bath_basis) J_list = [[-1, i, (i + 1) % L] for i in range(L)] M_list = [[1.0 / L**2, i, j] for i in range(L) for j in range(L)] N_list = [[1.0, 0]] I_list = [[L / 2.0, 0]] kwargs = dict(basis=basis, dtype=np.float64, check_symm=False, check_pcon=False, check_herm=False) print basis.basis_left.L H_S = hamiltonian([["zz|", J_list]], [], **kwargs) M2 = hamiltonian([["zz|", M_list]], [], **kwargs) n = hamiltonian([["|z", N_list], ["|I", I_list]], [], **kwargs) return H_S, M2, n
def check_z(L, dtype, Nf=None): J1 = [[2.0 * random() - 1.0, i, i] for i in range(L)] J0 = random() J2p = [[2.0 * J0 - 1.0, i, i + 1] for i in range(L - 1)] J2m = [[-(2.0 * J0 - 1.0), i, i + 1] for i in range(L - 1)] J1p = [[2.0 * J0 - 1.0, i, i + 1] for i in range(L - 1)] J1m = [[-(2.0 * J0 - 1.0), i, i + 1] for i in range(L - 1)] static = [["z|z", J1], ["+-|", J2p], ["-+|", J2m], ["|+-", J1p], ["|-+", J1m]] basis = spinful_fermion_basis_1d(L=L, Nf=Nf) H = hamiltonian(static, [], dtype=dtype, basis=basis, **no_checks) Ns = H.Ns E = H.eigvalsh() basis1 = spinful_fermion_basis_1d(L=L, Nf=Nf, sblock=1) H1 = hamiltonian(static, [], dtype=dtype, basis=basis1, **no_checks) basis2 = spinful_fermion_basis_1d(L=L, Nf=Nf, sblock=-1) H2 = hamiltonian(static, [], dtype=dtype, basis=basis2, **no_checks) E1 = H1.eigvalsh() E2 = H2.eigvalsh() Ez = np.concatenate((E1, E2)) Ez.sort() if norm(Ez - E) > eps(dtype): raise Exception( "test failed z symmetry at L={0:3d} with dtype {1} and Nf={2} {3}". format(L, np.dtype(dtype), Nf, norm(Ez - E)))
def check_m(Lmax): for dtype in dtypes: for L in range(2, Lmax + 1): h = [[2.0 * random() - 1.0, i] for i in range(L)] J1 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L)] J2_p = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L)] J2_m = [[-J2_p[i][0], i, (i + 1) % L] for i in range(L)] static = [["zz", J1], ["+-", J2_p], ["-+", J2_m], ["z", h]] basis = spinless_fermion_basis_1d(L=L) H = hamiltonian(static, [], dtype=dtype, basis=basis) Ns = H.Ns E = H.eigvalsh() Em = [] for Nf in range(L + 1): basis = spinless_fermion_basis_1d(L=L, Nf=Nf) H = hamiltonian(static, [], dtype=dtype, basis=basis) Etemp = H.eigvalsh() Em.append(Etemp) Em = np.concatenate(Em) Em.sort() if norm(Em - E) > Ns * eps(dtype): raise Exception( "test failed m symmetry at L={0:3d} with dtype {1} {2}". format(L, dtype, norm(Em - E)))
def spinOps(h1, h2, theta, phi, basis): mag1 = norm(h1) mag2 = norm(h2) zComp1 = mag1*np.cos(theta) #static comp. for 1 xComp1 = mag1*np.sin(theta)*np.cos(phi) yComp1 = mag1*np.sin(theta)*np.sin(phi) minus1 = [xComp1/2 - 1j*yComp1/2, 0] plus1 = [xComp1/2 + 1j*yComp1/2, 0] zComp2 = mag2*np.cos(theta) #static comp. for 2 xComp2 = mag2*np.sin(theta)*np.cos(phi) yComp2 = mag2*np.sin(theta)*np.sin(phi) minus2 = [xComp2/2 - 1j*yComp2/2, 0] plus2 = [xComp2/2 + 1j*yComp2/2, 0] static1 = [ ["z|",[[zComp1, 0]]], #z comp 1 ["-|", [minus1]], #- op 1 ["+|", [plus1]], #+ op 1 ] static2 = [ ["|z",[[zComp2, 0]]], #z comp 2 ["|-", [minus2]], #- op 2 ["|+", [plus2]] #+ op 2 ] H1 = hamiltonian(static1, [], dtype=np.complex128, basis=basis) #to make operators for 1 H2 = hamiltonian(static2, [], dtype=np.complex128, basis=basis) #to make operators for 2 return H1, H2
def check_p_z(L,dtype,Nup=None): h=[[1.0,i] for i in range(L)] J=[[1.0,i,(i+1)%L] for i in range(L-1)] if type(Nup) is int: static=[["zz",J],["yy",J],["xx",J]] else: static=[["zz",J],["x",h]] basis=spin_basis_1d(L=L,Nup=Nup) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() basis1=spin_basis_1d(L=L,Nup=Nup,pblock=1,zblock=1) H1=hamiltonian(static,[],dtype=dtype,basis=basis1) basis2=spin_basis_1d(L=L,Nup=Nup,pblock=-1,zblock=1) H2=hamiltonian(static,[],dtype=dtype,basis=basis2) basis3=spin_basis_1d(L=L,Nup=Nup,pblock=1,zblock=-1) H3=hamiltonian(static,[],dtype=dtype,basis=basis3) basis4=spin_basis_1d(L=L,Nup=Nup,pblock=-1,zblock=-1) H4=hamiltonian(static,[],dtype=dtype,basis=basis4) E1=H1.eigvalsh() E2=H2.eigvalsh() E3=H3.eigvalsh() E4=H4.eigvalsh() Epz=np.concatenate((E1,E2,E3,E4)) Epz.sort() if norm(Epz-E) > Ns*eps(dtype): raise Exception( "test failed p z symmetry at L={0:3d} with dtype {1} and Nup {2:2d} {3}".format(L,np.dtype(dtype),Nup,norm(Epz-E)) )
def check_pz(L,dtype,Nup=None): L_2=int(L/2) hr=[(i+0.1)**2/float(L**2) for i in range(L_2)] hi=[-(i+0.1)**2/float(L**2) for i in range(L_2)] hi.reverse() hi.extend(hr) h=[[hi[i],i] for i in range(L)] J=[[1.0,i,(i+1)%L] for i in range(L-1)] static=[["zz",J],["yy",J],["xx",J],["z",h]] basis=spin_basis_1d(L=L,Nup=Nup) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() basis1=spin_basis_1d(L=L,Nup=Nup,pzblock=1) H1=hamiltonian(static,[],dtype=dtype,basis=basis1) basis2=spin_basis_1d(L=L,Nup=Nup,pzblock=-1) H2=hamiltonian(static,[],dtype=dtype,basis=basis2) E1=H1.eigvalsh() E2=H2.eigvalsh() Epz=np.concatenate((E1,E2)) Epz.sort() if norm(Epz-E) > Ns*eps(dtype): raise Exception( "test failed pz symmetry at L={0:3d} with dtype {1} and Nup={2:2d} {3}".format(L,np.dtype(dtype),Nup,norm(Epz-E)) )
def check_t_z(L,dtype,Nup=None): hx=random() J=random() h=[[hx,i] for i in range(L)] J1=[[J,i,(i+1)%L] for i in range(L)] if type(Nup) is int: static=[["zz",J1],["yy",J1],["xx",J1]] else: static=[["zz",J1],["x",h]] L_2=int(L/2) for kblock in range(-L_2+1,L_2+1): basisk=spin_basis_1d(L=L,Nup=Nup,kblock=kblock) Hk=hamiltonian(static,[],dtype=dtype,basis=basisk) Ns=Hk.Ns Ek=Hk.eigvalsh() basisk1=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,zblock=+1) Hk1=hamiltonian(static,[],dtype=dtype,basis=basisk1) basisk2=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,zblock=-1) Hk2=hamiltonian(static,[],dtype=dtype,basis=basisk2) Ek1=Hk1.eigvalsh() Ek2=Hk2.eigvalsh() Ekz=np.append(Ek1,Ek2) Ekz.sort() if norm(Ek-Ekz) > Ns*eps(dtype): raise Exception( "test failed t z symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format(L,np.dtype(dtype),Nup,norm(Ek-Ekz)) )
def check_t(L,dtype,Nup=None): hx=random() J=random() h=[[hx,i] for i in range(L)] J1=[[J,i,(i+1)%L] for i in range(L)] if type(Nup) is int: static=[["zz",J1],["yy",J1],["xx",J1]] else: static=[["zz",J1],["x",h]] basis=spin_basis_1d(L=L,Nup=Nup) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() Et=np.array([]) for kblock in range(0,L): basisk=spin_basis_1d(L=L,Nup=Nup,kblock=kblock) Hk=hamiltonian(static,[],dtype=dtype,basis=basisk) Et=np.append(Et,Hk.eigvalsh()) Et.sort() if norm(Et-E) > Ns*eps(dtype): raise Exception( "test failed t symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format(L,np.dtype(dtype),Nup,norm(Et-E)) )
def check_t_zB(L,dtype,a=2): hx=random() J=random() h=[[hx,i] for i in range(L)] J1=[[J,i,(i+2)%L] for i in range(L)] static=[["zz",J1],["x",h]] L_2=int(L/a) for kblock in range(-L_2+2,L_2+2): basisk=spin_basis_1d(L=L,kblock=kblock,a=a) Hk=hamiltonian(static,[],dtype=dtype,basis=basisk) Ns=Hk.Ns Ek=Hk.eigvalsh() basisk1=spin_basis_1d(L=L,kblock=kblock,a=a,zBblock=+1) Hk1=hamiltonian(static,[],dtype=dtype,basis=basisk1) basisk2=spin_basis_1d(L=L,kblock=kblock,a=a,zBblock=-1) Hk2=hamiltonian(static,[],dtype=dtype,basis=basisk2) Ek1=Hk1.eigvalsh() Ek2=Hk2.eigvalsh() Ekz=np.append(Ek1,Ek2) Ekz.sort() if norm(Ek-Ekz) > Ns*eps(dtype): raise Exception( "test failed t zB symmetry at L={0:3d} with dtype {1} and {2}".format(L,np.dtype(dtype),norm(Ek-Ekz)) )
def check_m(Lmax): for dtype in dtypes: for L in range(2,Lmax+1): h=[[2.0*random()-1.0,i] for i in range(L)] J1=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L)] J2=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L)] static=[["zz",J1],["yy",J2],["xx",J2],["z",h]] basis=spin_basis_1d(L=L,pauli=False) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() Em=[] for Nup in range(L+1): basis=spin_basis_1d(L=L,pauli=False,Nup=Nup) H=hamiltonian(static,[],dtype=dtype,basis=basis) Etemp=H.eigvalsh() Em.append(Etemp) Em=np.concatenate(Em) Em.sort() if norm(Em-E) > Ns*eps(dtype): raise Exception( "test failed m symmetry at L={0:3d} with dtype {1} {2}".format(L,dtype,norm(Em-E) ) )
def check_z(L,dtype,Nup=None): if type(Nup) is int: J1=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L-1)] J2=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L-1)] static=[["zz",J1],["yy",J2],["xx",J2]] else: h=[[2.0*random()-1.0,i] for i in range(L)] J1=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L-1)] J2=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L-1)] static=[["zz",J1],["x",h]] basis=spin_basis_1d(L=L,Nup=Nup) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() basis1=spin_basis_1d(L=L,Nup=Nup,zblock=1) H1=hamiltonian(static,[],dtype=dtype,basis=basis1) basis2=spin_basis_1d(L=L,Nup=Nup,zblock=-1) H2=hamiltonian(static,[],dtype=dtype,basis=basis2) E1=H1.eigvalsh() E2=H2.eigvalsh() Ez=np.concatenate((E1,E2)) Ez.sort() if norm(Ez-E) > Ns*eps(dtype): raise Exception( "test failed z symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format(L,np.dtype(dtype),Nup, norm(Ez-E)))
def check_zA_zB(L,dtype): h=[[2.0*random()-1.0,i] for i in range(L)] J1=[[2.0*random()-1.0,i,(i+2)%L] for i in range(L-1)] J2=[[2.0*random()-1.0,i,(i+1)%L] for i in range(L-1)] static=[["zz",J1],["xx",J2],["x",h]] basis=spin_basis_1d(L=L) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() basis1=spin_basis_1d(L=L,zAblock=+1,zBblock=+1) H1=hamiltonian(static,[],dtype=dtype,basis=basis1) basis2=spin_basis_1d(L=L,zAblock=+1,zBblock=-1) H2=hamiltonian(static,[],dtype=dtype,basis=basis2) basis3=spin_basis_1d(L=L,zAblock=-1,zBblock=+1) H3=hamiltonian(static,[],dtype=dtype,basis=basis3) basis4=spin_basis_1d(L=L,zAblock=-1,zBblock=-1) H4=hamiltonian(static,[],dtype=dtype,basis=basis4) E1=H1.eigvalsh() E2=H2.eigvalsh() E3=H3.eigvalsh() E4=H4.eigvalsh() Ez=np.concatenate((E1,E2,E3,E4)) Ez.sort() if norm(Ez-E) > Ns*eps(dtype): raise Exception( "test failed zA zB symmetry at L={0:3d} with dtype {1} and {2}".format(L,np.dtype(dtype), norm(Ez-E)))
def check_zA_zB(L, dtype): h = [[2.0 * random() - 1.0, i] for i in range(L)] J1 = [[2.0 * random() - 1.0, i, (i + 2) % L] for i in range(L - 1)] J2 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L - 1)] static = [["zz", J1], ["xx", J2], ["x", h]] H = hamiltonian(static, [], N=L, dtype=dtype) Ns = H.Ns E = H.eigvalsh() H1 = hamiltonian(static, [], N=L, dtype=dtype, zAblock=+1, zBblock=+1) H2 = hamiltonian(static, [], N=L, dtype=dtype, zAblock=+1, zBblock=-1) H3 = hamiltonian(static, [], N=L, dtype=dtype, zAblock=-1, zBblock=+1) H4 = hamiltonian(static, [], N=L, dtype=dtype, zAblock=-1, zBblock=-1) E1 = H1.eigvalsh() E2 = H2.eigvalsh() E3 = H3.eigvalsh() E4 = H4.eigvalsh() Ez = np.concatenate((E1, E2, E3, E4)) Ez.sort() if norm(Ez - E) > Ns * eps(dtype): raise Exception( "test failed zA zB symmetry at L={0:3d} with dtype {1} and {2}".format(L, np.dtype(dtype), norm(Ez - E)) )
def check_t_zA_zB(L, dtype, a=2): hx = random() J = random() h = [[hx, i] for i in range(L)] J1 = [[J, i, (i + 2) % L] for i in range(L)] static = [["zz", J1], ["x", h]] L_2 = int(L / a) for kblock in range(0, L_2): Hk = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=+1, zBblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=+1, zBblock=-1, a=a) Hk3 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=-1, zBblock=+1, a=a) Hk4 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=-1, zBblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() Ek3 = Hk3.eigvalsh() Ek4 = Hk4.eigvalsh() Ekz = np.concatenate((Ek1, Ek2, Ek3, Ek4)) Ekz.sort() if norm(Ek - Ekz) > Ns * eps(dtype): raise Exception( "test failed t zA zB symmetry at L={0:3d} with dtype {1} and {2}".format( L, np.dtype(dtype), norm(Ek - Ekz) ) )
def check_p(L, dtype, Nup=None): L_2 = int(L / 2) hr = [2.0 * random() - 1.0 for i in range(L_2)] hi = [hr[i] for i in range(L_2)] hi.reverse() hi.extend(hr) h = [[hi[i], i] for i in range(L)] J = [[1.0, i, (i + 1) % L] for i in range(L - 1)] if type(Nup) is int: static = [["zz", J], ["yy", J], ["xx", J], ["z", h]] else: static = [["zz", J], ["x", h]] H = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype) Ns = H.Ns E = H.eigvalsh() H1 = hamiltonian(static, [], N=L, Nup=Nup, pblock=1, dtype=dtype) H2 = hamiltonian(static, [], N=L, Nup=Nup, pblock=-1, dtype=dtype) E1 = H1.eigvalsh() E2 = H2.eigvalsh() Ep = np.concatenate((E1, E2)) Ep.sort() if norm(Ep - E) > Ns * eps(dtype): raise Exception( "test failed p symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format( L, np.dtype(dtype), Nup, norm(Ep - E) ) )
def check_z(L, dtype, Nup=None): if type(Nup) is int: J1 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L - 1)] J2 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L - 1)] static = [["zz", J1], ["yy", J2], ["xx", J2]] else: h = [[2.0 * random() - 1.0, i] for i in range(L)] J1 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L - 1)] J2 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L - 1)] static = [["zz", J1], ["x", h]] H = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype) Ns = H.Ns E = H.eigvalsh() H1 = hamiltonian(static, [], N=L, Nup=Nup, zblock=1, dtype=dtype) H2 = hamiltonian(static, [], N=L, Nup=Nup, zblock=-1, dtype=dtype) E1 = H1.eigvalsh() E2 = H2.eigvalsh() Ez = np.concatenate((E1, E2)) Ez.sort() if norm(Ez - E) > Ns * eps(dtype): raise Exception( "test failed z symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format( L, np.dtype(dtype), Nup, norm(Ez - E) ) )
def check_p(L,dtype,Nup=None): L_2=int(L/2) hr=[2.0*random()-1.0 for i in range(L_2)] hi=[hr[i] for i in range(L_2)] hi.reverse() hi.extend(hr) h=[[hi[i],i] for i in range(L)] J=[[1.0,i,(i+1)%L] for i in range(L-1)] if type(Nup) is int: static=[["zz",J],["yy",J],["xx",J],["z",h]] else: static=[["zz",J],["x",h]] basis=spin_basis_1d(L=L,Nup=Nup) H=hamiltonian(static,[],dtype=dtype,basis=basis) Ns=H.Ns E=H.eigvalsh() basis1=spin_basis_1d(L=L,Nup=Nup,pblock=1) H1=hamiltonian(static,[],dtype=dtype,basis=basis1) basis2=spin_basis_1d(L=L,Nup=Nup,pblock=-1) H2=hamiltonian(static,[],dtype=dtype,basis=basis2) E1=H1.eigvalsh() E2=H2.eigvalsh() Ep=np.concatenate((E1,E2)) Ep.sort() if norm(Ep-E) > Ns*eps(dtype): raise Exception( "test failed p symmetry at L={0:3d} with dtype {1} and Nup={2} {3}".format(L,np.dtype(dtype),Nup,norm(Ep-E)) )
def test_Nup(n,m,S): nmax = int(eval("2*"+S)) N = n**2 + m**2 # Nups=range(nmax*N+1) Nups = [2] a_1 = np.array([0,1]) a_2 = np.array([1,0]) T1,t1,T2,t2,Pr,pr,Tx,Ty = tilted_square_transformations(n,m,a_1,a_2) Jzz = [[-1.0,i,Tx[i]] for i in range(N)] Jzz.extend([-1.0,i,Ty[i]] for i in range(N)) hx = [[-1.0,i] for i in range(N)] fzz = lambda x:1-x fx = lambda x:x dynamic=[["zz",Jzz,fzz,()],["+-",Jzz,fx,()],["-+",Jzz,fx,()]] ss = np.linspace(0,1,11) for Nup in Nups: basis_full = spin_basis_general(N,S=S,Nup=Nup) H_full = hamiltonian([],dynamic,basis=basis_full,dtype=np.float64) E_full = [] for s in ss: E_full.append(H_full.eigvalsh(time=s)) E_full = np.vstack(E_full) E_symm = np.zeros((E_full.shape[0],0),dtype=E_full.dtype) no_checks = dict(check_symm=False,check_pcon=False,check_herm=False) for blocks in get_blocks(T1,t1,T2,t2,Pr,pr): basis = spin_basis_general(N,S=S,Nup=Nup,**blocks) H = hamiltonian([],dynamic,basis=basis,dtype=np.complex128,**no_checks) if H.Ns == 0: continue block,values = zip(*blocks.items()) Tr,qs = zip(*values) print(basis.Ns,Nup,list(zip(block,qs))) for Hd in H._dynamic.values(): dH=(Hd-Hd.T.conj()) n = "{} {} {}".format(basis.Ns,Nup,list(zip(block,qs))) np.testing.assert_allclose(dH.data,0,atol=1e-7,err_msg=str(n)) E_list = [] for i,s in enumerate(ss): E = H.eigvalsh(time=s) E_list.append(E) E_list = np.vstack(E_list) E_symm = np.hstack((E_symm,E_list)) E_symm.sort(axis=1) np.testing.assert_allclose(E_symm,E_full,atol=1e-13)
def getvec(L,Nup=None,kblock=None,pblock=None,zblock=None,pzblock=None,a=1,sparse=True): jb=[[i,1.0] for i in range(L)] dtype=np.complex128 b = spin_basis_1d(L,Nup=Nup,kblock=kblock,pblock=pblock,zblock=zblock,pzblock=pzblock,a=a) Ns = b.Ns static = [ ['xx',J(L,jb,2)], ['yy',J(L,jb,2)], ['zz',J(L,jb,2)], ['+-',J(L,jb,2)], ['-+',J(L,jb,2)], ['zzzz',J(L,jb,4)], ['xxxx',J(L,jb,4)], ['yyyy',J(L,jb,4)], ['xxzz',J(L,jb,4)], ['zzxx',J(L,jb,4)], ['yyzz',J(L,jb,4)], ['zzyy',J(L,jb,4)], ['yyxx',J(L,jb,4)], ['xxyy',J(L,jb,4)], ['+zz-',J(L,jb,4)], ['-zz+',J(L,jb,4)], ['+xx-',J(L,jb,4)], ['-xx+',J(L,jb,4)], ['+yy-',J(L,jb,4)], ['-yy+',J(L,jb,4)], ['++--',J(L,jb,4)], ['--++',J(L,jb,4)], ['+-+-',J(L,jb,4)], ['-+-+',J(L,jb,4)], ] H1 = hamiltonian(static,[],N=L,dtype=dtype) H2 = hamiltonian(static,[],basis=b,dtype=dtype) E,v0 = H2.eigh() v = b.get_vec(v0,sparse=sparse) P = b.get_proj(dtype=np.complex128) if sp.issparse(v): v = v.todense() if v.shape[0] != 0: H1 = H1.todense() H2 = H2.todense() H2 = v0.T.conj() * (H2 * v0) H1 = v.T.conj().dot(H1.dot(v)) if np.abs(np.linalg.norm(H1-H2)) > 10**(-10): raise Exception("get_vec() failed {0}".format(b.blocks)) else: pass
def __init__(self, L=1, J=1.0, hz=1.0, hx_min=-4., hx_max=4., dh=2., n_step=1, symm=True, **kwargs): # N is the number of time steps #basis = spin_basis_1d(L=L,pauli=False) fct_arg = [] ones = [[-1, i] for i in range(L)] z_field = [[-hz, i] for i in range(L)] if L > 1: if symm is True: basis = spin_basis_1d( L=L, pauli=False, kblock=0, pblock=1 ) # include symmetries (momentum and parity sectors) else: basis = spin_basis_1d(L=L, pauli=False) # w/o symmetries zz_int = [[-J, i, (i + 1) % L] for i in range(L)] # Has periodic boundary conditions static = [["zz", zz_int], ["z", z_field]] else: basis = spin_basis_1d( L=L, pauli=False) # w/o symmetries (momentum and parity sectors) static = [["z", z_field]] self.h_set = self.compute_h_set( hx_min, hx_max, dh) # discrete set of possible h fields self.hx_discrete = np.zeros( n_step, dtype=int) # hx_discrete are protocols specified as integers fct = lambda time: self.h_set[self.hx_discrete[int( time)]] # time takes discrete values in our problem fct_cont = lambda h: h # trick : when calling the time - will instead interpret it as a field value dynamic_discrete = [["x", ones, fct, fct_arg]] dynamic_cont = [["x", ones, fct_cont, fct_arg]] kwargs = { 'dtype': np.float64, 'basis': basis, 'check_symm': False, 'check_herm': False, 'check_pcon': False } self.basis = basis self.hamiltonian_discrete = hamiltonian(static, dynamic_discrete, **kwargs) self.hamiltonian_cont = hamiltonian(static, dynamic_cont, **kwargs)
def check_t_zA_zB(L, dtype, a=2): hx = random() J = random() h = [[hx, i] for i in range(L)] J1 = [[J, i, (i + 2) % L] for i in range(L)] static = [["zz", J1], ["x", h]] L_2 = int(L / a) for kblock in range(0, L_2): Hk = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=+1, zBblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=+1, zBblock=-1, a=a) Hk3 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=-1, zBblock=+1, a=a) Hk4 = hamiltonian(static, [], N=L, dtype=dtype, kblock=kblock, zAblock=-1, zBblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() Ek3 = Hk3.eigvalsh() Ek4 = Hk4.eigvalsh() Ekz = np.concatenate((Ek1, Ek2, Ek3, Ek4)) Ekz.sort() if norm(Ek - Ekz) > Ns * eps(dtype): raise Exception( "test failed t zA zB symmetry at L={0:3d} with dtype {1} and {2}" .format(L, np.dtype(dtype), norm(Ek - Ekz)))
def get_operators(size, Nb): n, m = size if Nb % 2 == 1: S = "{}/2".format(Nb) else: S = "{}".format(Nb // 2) bath_basis = spin_basis_general(1, S=S) N = n**2 + m**2 Ns_block_est = max((2**N) / (N), 1000) if n != 0: T1, t1, T2, t2, Pr, pr, Tx, Ty = tilted_square_transformations(n, m) blocks = dict(tx=(Tx, 0), ty=(Ty, 0), pb=(Pr, 0)) spin_basis = spin_basis_general(N, S="1/2", pauli=True, Ns_block_est=Ns_block_est, **blocks) else: L = m tr = square_lattice_trans(L, L) Tx = tr.T_x Ty = tr.T_y blocks = dict(tx=(Tx, 0), ty=(Ty, 0), px=(tr.P_x, 0), py=(tr.P_y, 0), pd=(tr.P_d, 0)) spin_basis = spin_basis_general(N, S="1/2", pauli=True, Ns_block_est=Ns_block_est, **blocks) basis = tensor_basis(spin_basis, bath_basis) J_list = [[-1.0, i, Tx[i]] for i in range(N)] J_list.extend([-1.0, i, Ty[i]] for i in range(N)) M_list = [[1.0 / N**2, i, i] for i in range(N)] M_list += [[2.0 / N**2, i, j] for i in range(N) for j in range(N) if i > j] kwargs = dict(basis=basis, dtype=np.float64, check_symm=False, check_pcon=False, check_herm=False) print size H_S = hamiltonian([["zz|", J_list]], [], **kwargs) M2 = hamiltonian([["zz|", M_list]], [], **kwargs) return H_S, M2
def test(S,Lx,Ly): N = Lx*Ly nmax = int(eval("2*"+S)) sps = nmax+1 tr = square_lattice_trans(Lx,Ly) basis_dict = {} Nups=range(nmax*N+1) for Nup in Nups: basis_blocks=[] pcon_basis = spin_basis_general(N,Nup=Nup,S=S) Ns_block = 0 for blocks in tr.allowed_blocks_spin_inversion_iter(Nup,sps): basis = spin_basis_general(N,Nup=Nup,S=S,**blocks) Ns_block += basis.Ns basis_blocks.append(basis) try: assert(Ns_block == pcon_basis.Ns) except AssertionError: print(Nup,Ns_block,pcon_basis.Ns) raise AssertionError("reduced blocks don't sum to particle sector.") basis_dict[Nup] = (pcon_basis,basis_blocks) J = [[1.0,i,tr.T_x[i]] for i in range(N)] J.extend([[1.0,i,tr.T_y[i]] for i in range(N)]) static = [["zz",J],["+-",J],["-+",J]] E_symm = {} for Nb,(pcon_basis,basis_blocks) in basis_dict.items(): H_pcon = hamiltonian(static,[],basis=pcon_basis,dtype=np.float64) if H_pcon.Ns>0: E_pcon = np.linalg.eigvalsh(H_pcon.todense()) else: E_pcon = np.array([]) E_block = [] for basis in basis_blocks: H = hamiltonian(static,[],basis=basis,dtype=np.complex128) if H.Ns>0: E_block.append(np.linalg.eigvalsh(H.todense())) E_block = np.hstack(E_block) E_block.sort() np.testing.assert_allclose(E_pcon,E_block,atol=1e-13) print("passed Nb={} sector".format(Nb))
def _setup_basis(self, **args_model): """ Build and store: - the basis (self._ss) and the basis without use of symmetries() - config_system """ config_bh1D = {} for p in ['L', 'Nb']: config_bh1D[p] = args_model[p] for p in ['sps', 'kblock', 'pblock']: config_bh1D[p] = args_model.get(p, self._LIST_ARGS_OPT[p][1]) self._ss = boson_basis_1d(**config_bh1D) if np.any([config_bh1D[p] is not None for p in ['kblock', 'pblock']]): self._flag_basis_symm = True config_bh1D['pblock'] = None config_bh1D['kblock'] = None self._ss_nosym = boson_basis_1d(**config_bh1D) self._P = self._ss.get_proj(dtype=np.complex128, pcon=True) self._op_n_sites = None ## there is way to define it using projection else: L = args_model['L'] self._flag_basis_symm = False self._ss_nosym = self._ss self._P = None #Id self._op_n_sites = [ hamiltonian([['n', [[1.0, i]]]], [], basis=self._ss_nosym, dtype=np.float64) for i in range(L) ] i_iplusN = [[1, i, (i + L - 1) % L] for i in range(L)] # Cyclical boundaries self._op_correl_N = [ hamiltonian([['+-', i_iplusN]], [], basis=self._ss_nosym, dtype=np.float64, check_herm=False) for i in range(L) ] Ns = self._ss.Ns #NEW: get the basis.. A little bit convoluted may be an easier way to do that # Dim_H x Nbsites self._basis_fock = np.array( [self._get_basis_to_fock(s) for s in range(Ns)]) # store the index of MI (i.e. 11...11) if (config_bh1D['L'] == config_bh1D['Nb']): self._index_basis_allone = np.where( [np.allclose(b, 1.) for b in self._basis_fock])[0][0] else: self._index_basis_allone = -1 self._index_basis_oneone = [ np.where([b[i] == 1. for b in self._basis_fock])[0] for i in range(L) ]
def create_number_operator(self): num_list = [[1, _] for _ in range(self.perimeter_params.nx)] self.operator_dict['n'] = hamiltonian( [["n|", num_list], ["|n", num_list]], [], basis=self.basis) for j in range(self.perimeter_params.nx): self.operator_dict['num' + str(j)] = hamiltonian( [["+-|", [ [1, j, j], ]], ["|+-", [ [1, j, j], ]]], [], basis=self.basis)
def auto_correlator_symm(L, times, S="1/2"): # define momentum p sector of the GS of the Heisenberg Hamiltonian if (L // 2) % 2: p = L // 2 # corresponds to momentum pi dtype = np.complex128 else: p = 0 dtype = np.float64 # # define translation operator T = (np.arange(L) + 1) % L # compute the basis in the momentum sector of the GS of the Heisenberg model basis_p = spin_basis_general(L, S=S, m=0, kblock=(T, p), pauli=False) # define Heisenberg Hamiltonian no_checks = dict(check_symm=False, check_herm=False, check_pcon=False) H = hamiltonian(static, [], basis=basis_p, dtype=dtype, **no_checks) # compute GS E, V = H.eigsh(k=1, which="SA") psi_GS = V[:, 0] # evolve GS under symmetry-reduced H (gives a trivial phase factor) psi_GS_t = H.evolve(psi_GS, 0, times) # ##### compute autocorrelation function foe every momentum sector Cq_t = np.zeros((times.shape[0], L), dtype=np.complex128) # for q in range(L): # sum over symmetry sectors # ###### define operator O_q, sum over lattice sites op_list = [[ "z", [j], (np.sqrt(2.0) / L) * np.exp(-1j * 2.0 * np.pi * q * j / L) ] for j in range(L)] # compute basis in the (q+p)-momentum sector (the total momentum of O_q|psi_GS> is q+p) basis_q = spin_basis_general(L, S=S, m=0, kblock=(T, p + q), pauli=False) # define Hamiltonian in the q-momentum sector Hq = hamiltonian(static, [], basis=basis_q, dtype=np.complex128, **no_checks) # use Op_shift_sector apply operator O_q to GS; the momentum of the new state is p+q Opsi_GS = basis_q.Op_shift_sector(basis_p, op_list, psi_GS) # time evolve Opsi_GS under H_q Opsi_GS_t = Hq.evolve(Opsi_GS, 0.0, times) # apply operator O on time-evolved psi_t O_psi_GS_t = basis_q.Op_shift_sector(basis_p, op_list, psi_GS_t) # compute autocorrelator for every momentum sector Cq_t[..., q] = np.einsum("ij,ij->j", O_psi_GS_t.conj(), Opsi_GS_t) # return np.sum(Cq_t, axis=1) # sum over momentum sectors
def test(Lx, Ly): N = Lx * Ly tr = square_lattice_trans(Lx, Ly) basis_dict = {} Nfs = range(N + 1) for Nf in Nfs: basis_blocks = [] pcon_basis = spinless_fermion_basis_general(N, Nf=Nf) Ns_block = 0 for blocks in tr.allowed_blocks_iter_parity(): basis = spinless_fermion_basis_general(N, Nf=Nf, **blocks) Ns_block += basis.Ns basis_blocks.append(basis) assert (Ns_block == pcon_basis.Ns) basis_dict[Nf] = (pcon_basis, basis_blocks) J = [[np.sqrt(2.0), i, tr.T_x[i]] for i in range(N)] J.extend([[np.sqrt(2.0), i, tr.T_y[i]] for i in range(N)]) Jp = [[1.0, i, tr.T_x[i]] for i in range(N)] Jp.extend([[1.0, i, tr.T_y[i]] for i in range(N)]) Jm = [[-1.0, i, tr.T_x[i]] for i in range(N)] Jm.extend([[-1.0, i, tr.T_y[i]] for i in range(N)]) static = [["nn", J], ["+-", Jp], ["-+", Jm]] E_symm = {} for Nf, (pcon_basis, basis_blocks) in basis_dict.items(): H_pcon = hamiltonian(static, [], basis=pcon_basis, dtype=np.float64) if H_pcon.Ns > 0: E_pcon = np.linalg.eigvalsh(H_pcon.todense()) else: E_pcon = np.array([]) E_block = [] for basis in basis_blocks: H = hamiltonian(static, [], basis=basis, dtype=np.complex128) if H.Ns > 0: E_block.append(np.linalg.eigvalsh(H.todense())) E_block = np.hstack(E_block) E_block.sort() print(Nf) print(E_pcon) print(E_block) np.testing.assert_allclose(E_pcon, E_block, atol=1e-13) print("passed Nf={} sector".format(Nf))
def corr_symm(L, times, S="1/2"): J_list = [[1.0, i, (i + 1) % L] for i in range(L)] static = [[op, J_list] for op in ["-+", "+-", "zz"]] if (L // 2) % 2: q0 = L // 2 dtype = np.complex128 else: q0 = 0 dtype = np.float64 t = (np.arange(L) + 1) % L basis = spin_basis_general(L, S=S, m=0, kblock=(t, q0), pauli=False) kwargs = dict(basis=basis, dtype=dtype, check_symm=False, check_herm=False, check_pcon=False) H = hamiltonian(static, [], **kwargs) E, V = H.eigsh(k=1, which="SA") psi0 = V[:, 0] sqs = [] psi0_t = H.evolve(psi0.ravel(), 0, times) for q in range(L): op_pq = [["z", [i], (2.0 / L) * np.exp(-2j * np.pi * q * i / L)] for i in range(L)] basis_q = spin_basis_general(L, S=S, m=0, kblock=(t, q0 + q), pauli=False) kwargs = dict(basis=basis_q, dtype=np.complex128, check_symm=False, check_herm=False, check_pcon=False) Hq = hamiltonian(static, [], **kwargs) psi1 = basis_q.Op_shift_sector(basis, op_pq, psi0) psi1_t = Hq.evolve(psi1, 0, times) psi2_t = basis_q.Op_shift_sector(basis, op_pq, psi0_t) sqs.append(np.einsum("ij,ij->j", psi2_t.conj(), psi1_t)) return sum(sqs)
def ham(L, basis, hop, int, W, Dis_type, seed=None): op_static, op_dynamic = op_list(hop, int) no_checks = {"check_herm": False, "check_pcon": False, "check_symm": False} clean_ham = hamiltonian( op_static, op_dynamic, basis=basis, dtype=np.float64, **no_checks) #clean XXZ Hamiltonian with no disorder h_z, dis_static = field_list(L, Dis_type, seed) dis_ham = hamiltonian(dis_static, op_dynamic, basis=basis, dtype=np.float64, **no_checks) tot_ham = clean_ham + W * dis_ham #disordered XXZ Hamiltonian return tot_ham
def test(sps, Lx, Ly): N = Lx * Ly nmax = sps - 1 tr = square_lattice_trans(Lx, Ly) basis_dict = {} Nbs = range(nmax * N + 1) for Nb in Nbs: basis_blocks = [] pcon_basis = boson_basis_general(N, Nb=Nb, sps=sps) Ns_block = 0 for blocks in tr.allowed_blocks_iter(): basis = boson_basis_general(N, Nb=Nb, sps=sps, **blocks) Ns_block += basis.Ns basis_blocks.append(basis) try: assert (Ns_block == pcon_basis.Ns) except AssertionError: print(Ns_block, pcon_basis.Ns) raise AssertionError basis_dict[Nb] = (pcon_basis, basis_blocks) J = [[1.0, i, tr.T_x[i]] for i in range(N)] J.extend([[1.0, i, tr.T_y[i]] for i in range(N)]) static = [["nn", J], ["+-", J], ["-+", J]] E_symm = {} for Nb, (pcon_basis, basis_blocks) in basis_dict.items(): H_pcon = hamiltonian(static, [], basis=pcon_basis, dtype=np.float64) if H_pcon.Ns > 0: E_pcon = np.linalg.eigvalsh(H_pcon.todense()) else: E_pcon = np.array([]) E_block = [] for basis in basis_blocks: H = hamiltonian(static, [], basis=basis, dtype=np.complex128) if H.Ns > 0: E_block.append(np.linalg.eigvalsh(H.todense())) E_block = np.hstack(E_block) E_block.sort() np.testing.assert_allclose(E_pcon, E_block, atol=1e-13) print("passed Nb={} sector".format(Nb))
def exact_diag(J,Hx,Hz,Lx,Ly): N_2d = Lx*Ly # number of sites ###### setting up user-defined symmetry transformations for 2d lattice ###### s = np.arange(N_2d) # sites [0,1,2,....] x = s%Lx # x positions for sites y = s//Lx # y positions for sites T_x = (x+1)%Lx + Lx*y # translation along x-direction T_y = x +Lx*((y+1)%Ly) # translation along y-direction mT_y = x +Lx*((y+Ly-1)%Ly) # translation along y-direction P_x = x + Lx*(Ly-y-1) # reflection about x-axis P_y = (Lx-x-1) + Lx*y # reflection about y-axis Z = -(s+1) # spin inversion ###### setting up bases ###### # basis_2d = spin_basis_general(N=N_2d,S="1/2",pauli=0) basis_2d = spin_basis_general(N=N_2d,S="1/2",pauli=0,kxblock=(T_x,0),kyblock=(T_y,0)) ###### setting up hamiltonian ###### # setting up site-coupling lists Jzzs = [[J,i,T_x[i]] for i in range(N_2d)]+[[J,i,T_y[i]] for i in range(N_2d)] Hxs = [[-Hx,i] for i in range(N_2d)] Hzs = [[-Hz,i] for i in range(N_2d)] static = [["zz",Jzzs],["x",Hxs],["z",Hzs]] # build hamiltonian # H = hamiltonian(static,[],static_fmt="csr",basis=basis_2d,dtype=np.float64) no_checks = dict(check_symm=False, check_pcon=False, check_herm=False) H = hamiltonian(static,[],static_fmt="csr",basis=basis_2d,dtype=np.float64,**no_checks) # diagonalise H ene,vec = H.eigsh(time=0.0,which="SA",k=2) # ene = H.eigsh(time=0.0,which="SA",k=2,return_eigenvectors=False); ene = np.sort(ene) norm2 = np.linalg.norm(vec[:,0])**2 # calculate uniform magnetization int_mx = [[1.0,i] for i in range(N_2d)] int_mz = [[1.0,i] for i in range(N_2d)] static_mx = [["x",int_mx]] static_mz = [["z",int_mz]] op_mx = hamiltonian(static_mx,[],static_fmt="csr",basis=basis_2d,dtype=np.float64,**no_checks).tocsr(time=0) op_mz = hamiltonian(static_mz,[],static_fmt="csr",basis=basis_2d,dtype=np.float64,**no_checks).tocsr(time=0) mx = (np.conjugate(vec[:,0]).dot(op_mx.dot(vec[:,0])) / norm2).real / N_2d mz = (np.conjugate(vec[:,0]).dot(op_mz.dot(vec[:,0])) / norm2).real / N_2d # calculate n.n. sz.sz correlation int_mz0mz1 = [[1.0,i,T_x[i]] for i in range(N_2d)]+[[1.0,i,T_y[i]] for i in range(N_2d)] static_mz0mz1 = [["zz",int_mz0mz1]] op_mz0mz1 = hamiltonian(static_mz0mz1,[],static_fmt="csr",basis=basis_2d,dtype=np.float64,**no_checks).tocsr(time=0) mz0mz1 = (np.conjugate(vec[:,0]).dot(op_mz0mz1.dot(vec[:,0])) / norm2).real / N_2d # calculate sz(0,0).sz(1,1) correlation int_mz0mzsq2 = [[1.0,i,T_y[T_x[i]]] for i in range(N_2d)]+[[1.0,i,mT_y[T_x[i]]] for i in range(N_2d)] static_mz0mzsq2 = [["zz",int_mz0mzsq2]] op_mz0mzsq2 = hamiltonian(static_mz0mzsq2,[],static_fmt="csr",basis=basis_2d,dtype=np.float64,**no_checks).tocsr(time=0) mz0mzsq2 = (np.conjugate(vec[:,0]).dot(op_mz0mzsq2.dot(vec[:,0])) / norm2).real / N_2d return ene, mx, mz, mz0mz1, mz0mzsq2
def create_time_dependent_current_operator(self): no_checks = dict(check_pcon=False, check_symm=False, check_herm=False) perpa = self.perimeter_params dynamic_args = [perpa, self.cycles] for j in range(self.perimeter_params.nx - 1): K = hamiltonian([], [["+-|", [ [1, j, j + 1], ], expiphi, dynamic_args], ["|+-", [ [1, j, j + 1], ], expiphi, dynamic_args]], basis=self.basis, **no_checks) K_h = hamiltonian( [], [["+-|", [ [1, j + 1, j], ], expiphiconj, dynamic_args], ["|+-", [ [1, j + 1, j], ], expiphiconj, dynamic_args]], basis=self.basis, **no_checks) self.operator_dict["current" + str(j)] = -1j * perpa.a * perpa.t * (K - K_h) if self.perimeter_params.pbc: K = hamiltonian( [], [["+-|", [ [1, perpa.nx - 1, 0], ], expiphi, dynamic_args], ["|+-", [ [1, perpa.nx - 1, 0], ], expiphi, dynamic_args]], basis=self.basis, **no_checks) K_h = hamiltonian( [], [["+-|", [ [1, 0, perpa.nx - 1], ], expiphiconj, dynamic_args], ["|+-", [ [1, 0, perpa.nx - 1], ], expiphiconj, dynamic_args]], basis=self.basis, **no_checks) self.operator_dict["current" + str(perpa.nx - 1)] = -1j * perpa.a * perpa.t * (K - K_h)
def check_p_z(L, dtype, Nf=None): L_2 = int(L / 2) hr = [2.0 * random() - 1.0 for i in range(L_2)] hi = [hr[i] for i in range(L_2)] hi.reverse() hi.extend(hr) h = [[hi[i], i] for i in range(L)] J = [[1.0, i, i] for i in range(L)] J0 = random() Jp = [[2.0 * J0 - 1.0, i, i + 1] for i in range(L - 1)] Jm = [[-(2.0 * J0 - 1.0), i, i + 1] for i in range(L - 1)] if type(Nf) is tuple: if type(Nf[0]) is int and type(Nf[1]) is int: static = [["z|z", J], ["+-|", Jp], ["-+|", Jm], ["|+-", Jp], ["|-+", Jm], ["z|", h], ["|z", h]] else: static = [["z|z", J], ["+|", h], ["-|", h], ["|+", h], ["|-", h]] basis = spinful_fermion_basis_1d(L=L, Nf=Nf) H = hamiltonian(static, [], dtype=dtype, basis=basis, **no_checks) Ns = H.Ns E = H.eigvalsh() basis1 = spinful_fermion_basis_1d(L=L, Nf=Nf, pblock=1, sblock=1) H1 = hamiltonian(static, [], dtype=dtype, basis=basis1, **no_checks) basis2 = spinful_fermion_basis_1d(L=L, Nf=Nf, pblock=-1, sblock=1) H2 = hamiltonian(static, [], dtype=dtype, basis=basis2, **no_checks) basis3 = spinful_fermion_basis_1d(L=L, Nf=Nf, pblock=1, sblock=-1) H3 = hamiltonian(static, [], dtype=dtype, basis=basis3, **no_checks) basis4 = spinful_fermion_basis_1d(L=L, Nf=Nf, pblock=-1, sblock=-1) H4 = hamiltonian(static, [], dtype=dtype, basis=basis4, **no_checks) E1 = H1.eigvalsh() E2 = H2.eigvalsh() E3 = H3.eigvalsh() E4 = H4.eigvalsh() Epz = np.concatenate((E1, E2, E3, E4)) Epz.sort() if norm(Epz - E) > eps(dtype): raise Exception( "test failed pz symmetry at L={0:3d} with dtype {1} and Nf={2:2d} {3}" .format(L, np.dtype(dtype), Nf, norm(Epz - E)))
def Hamiltonian(L, J, hz, hx, fct=None): #basis = spin_basis_1d(L=L,pauli=False) fct_arg = [] ones = [[-1, i] for i in range(L)] z_field = [[-hz, i] for i in range(L)] if L > 1: basis = spin_basis_1d(L=L, pauli=False, kblock=0, pblock=1) zz_int = [[-J, i, (i + 1) % L] for i in range(L)] # Has periodic boundary conditions static = [["zz", zz_int], ["z", z_field]] else: basis = spin_basis_1d(L=L, pauli=False) static = [["z", z_field]] dynamic = [["x", ones, fct, fct_arg]] kwargs = { 'dtype': np.float64, 'basis': basis, 'check_symm': False, 'check_herm': False, 'check_pcon': False } return hamiltonian(static, dynamic, **kwargs), basis
def spin_entropy(dtype, symm, Sent_args): if symm: basis = spin_basis_1d(L, kblock=0, pblock=1, zblock=1) else: basis = spin_basis_1d(L) # define operators with OBC using site-coupling lists J_zz = [[1.0, i, (i + 1) % L, (i + 2) % L] for i in range(0, L)] J_xy = [[1.0, i, (i + 1) % L] for i in range(0, L)] # static and dynamic lists static = [["+-", J_xy], ["-+", J_xy], ["zxz", J_zz]] # build Hamiltonian H = hamiltonian(static, [], basis=basis, dtype=dtype, check_herm=False, check_symm=False) # diagonalise H E, V = H.eigh() psi0 = V[:, 0] rho0 = np.outer(psi0.conj(), psi0) rho_d = rho0 Ed, Vd = np.linalg.eigh(rho_d) S_pure = ent_entropy(psi0, basis, **Sent_args) S_DM = ent_entropy(rho0, basis, **Sent_args) S_DMd = ent_entropy({"V_rho": Vd, "rho_d": abs(Ed)}, basis, **Sent_args) S_all = ent_entropy({"V_states": V}, basis, **Sent_args) return (S_pure, S_DM, S_DMd, S_all)
def check_opstr(Lmax): for dtype in dtypes: for L in range(2, Lmax + 1): h = [[2.0 * random() - 1.0, i] for i in range(L)] J1 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L)] J2 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L)] J3 = [[J2[i][0] * 0.5, i, (i + 1) % L] for i in range(L)] static1 = [["zz", J1], ["yy", J2], ["xx", J2], ["x", h]] static2 = [["zz", J1], ["+-", J3], ["-+", J3], ["x", h]] H1 = hamiltonian(static1, [], N=L, dtype=dtype, pauli=False) H2 = hamiltonian(static2, [], N=L, dtype=dtype, pauli=False) if norm(H1.todense() - H2.todense()) > eps(dtype): raise Exception( "test failed opstr at L={0:3d} with dtype {1} {2}".format(L, np.dtype(dtype)), norm(H1.todense() - H2.todense()), )
def getvec_zA_zB(L,kblock=None,zAblock=None,zBblock=None,a=2,sparse=True): jb=[[i,1.0] for i in range(L)] dtype=np.complex128 b_zA_zB = spin_basis_1d(L,kblock=kblock,zAblock=zAblock,zBblock=zBblock,a=a) Ns_zA_zB = b_zA_zB.Ns static_zA_zB = [ ['xx',J(L,jb,2)], ['zz',Jnn(L,jb,2)], ['zxz',J(L,jb,3)], ['zxzx',J(L,jb,4)], ['xxxx',J(L,jb,4)], ['yyyy',J(L,jb,4)], ['xzxz',J(L,jb,4)], ['yzyz',J(L,jb,4)], ['zyzy',J(L,jb,4)], ['z+z-',J(L,jb,4)], ['z-z+',J(L,jb,4)], ] H1 = hamiltonian(static_zA_zB,[],N=L,dtype=dtype) H2_zA_zB = hamiltonian(static_zA_zB,[],N=L,basis=b_zA_zB,dtype=dtype) E_zA_zB,v0_zA_zB=H2_zA_zB.eigh() v_zA_zB = b_zA_zB.get_vec(v0_zA_zB,sparse=sparse) if sp.issparse(v_zA_zB): v_zA_zB = v_zA_zB.todense() if v_zA_zB.shape[0] != 0: H1 = H1.todense() H2_zA_zB = H2_zA_zB.todense() H2_zA_zB = v0_zA_zB.T.conj() * (H2_zA_zB * v0_zA_zB) H1 = v_zA_zB.T.conj() * ( H1 * v_zA_zB) if np.abs(np.linalg.norm(H1-H2_zA_zB)) > 10**(-10): raise Exception("get_vec() zA_zB failed {0}") else: pass
def check_m(Lmax): for dtype in dtypes: for L in range(2, Lmax + 1): h = [[2.0 * random() - 1.0, i] for i in range(L)] J1 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L)] J2 = [[2.0 * random() - 1.0, i, (i + 1) % L] for i in range(L)] static = [["zz", J1], ["yy", J2], ["xx", J2], ["z", h]] H = hamiltonian(static, [], N=L, dtype=dtype, pauli=False) Ns = H.Ns E = H.eigvalsh() Em = [] for Nup in range(L + 1): H = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, pauli=False) Etemp = H.eigvalsh() Em.append(Etemp) Em = np.concatenate(Em) Em.sort() if norm(Em - E) > Ns * eps(dtype): raise Exception("test failed m symmetry at L={0:3d} with dtype {1} {2}".format(L, dtype, norm(Em - E)))
def spin_photon_entropy(dtype, symm, Sent_args): Nph = 6 if symm: basis = photon_basis(spin_basis_1d, L, Nph=Nph, kblock=0, pblock=1) else: basis = photon_basis(spin_basis_1d, L, Nph=Nph) # spin x_field = [[-1.0, i] for i in range(L)] z_field = [[-1.0, i] for i in range(L)] J_nn = [[-1.0, i, (i + 1) % L] for i in range(L)] # spin-photon absorb = [[-0.5 * 1.0 / np.sqrt(Nph), i] for i in range(L)] emit = [[-0.5 * np.conj(1.0) / np.sqrt(Nph), i] for i in range(L)] # photon ph_energy = [[11.0 / L, i] for i in range(L)] static = [["zz|", J_nn], ["z|", z_field], ["x|", x_field], ["x|-", absorb], ["x|+", emit], ["I|n", ph_energy]] H = hamiltonian(static, [], L, dtype=np.float64, basis=basis, check_herm=False, check_symm=False) # diagonalise H E, V = H.eigh() psi0 = V[:, 0] rho0 = np.outer(psi0.conj(), psi0) rho_d = rho0 Ed, Vd = np.linalg.eigh(rho_d) S_pure = ent_entropy(psi0, basis, **Sent_args) S_DM = ent_entropy(rho0, basis, **Sent_args) S_DMd = ent_entropy({"V_rho": Vd, "rho_d": abs(Ed)}, basis, **Sent_args) S_all = ent_entropy({"V_states": V}, basis, **Sent_args) return (S_pure, S_DM, S_DMd, S_all)
def check_t_p_z(L, dtype, Nup=None): hx = random() J = random() h = [[hx, i] for i in range(L)] J1 = [[J, i, (i + 1) % L] for i in range(L)] if type(Nup) is int: static = [["zz", J1], ["xx", J1], ["yy", J1]] else: static = [["zz", J1], ["x", h]] L_2 = int(L / 2) for kblock in range(-L_2 + 1, L_2 + 1): Hkp1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pblock=+1) Hkp2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pblock=-1) Ns = Hkp1.Ns Ekp1 = Hkp1.eigvalsh() Ekp2 = Hkp2.eigvalsh() Hkpz11 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pblock=+1, zblock=+1) Hkpz12 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pblock=+1, zblock=-1) Ekpz11 = Hkpz11.eigvalsh() Ekpz12 = Hkpz12.eigvalsh() Ekpz1 = np.concatenate((Ekpz11, Ekpz12)) Ekpz1.sort() Hkpz21 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pblock=-1, zblock=+1) Hkpz22 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pblock=-1, zblock=-1) Ekpz21 = Hkpz21.eigvalsh() Ekpz22 = Hkpz22.eigvalsh() Ekpz2 = np.concatenate((Ekpz21, Ekpz22)) Ekpz2.sort() if norm(Ekp1 - Ekpz1) > Ns * eps(dtype): raise Exception( "test failed t z p+ symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ekp1 - Ekpz1) ) ) if norm(Ekp2 - Ekpz2) > Ns * eps(dtype): raise Exception( "test failed t z p- symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ekp2 - Ekpz2) ) ) if kblock not in [0, L_2]: if norm(Ekp2 - Ekpz1) > Ns * eps(dtype): raise Exception( "test failed t z p+ symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ekp2 - Ekpz1) ) ) if norm(Ekp1 - Ekpz2) > Ns * eps(dtype): raise Exception( "test failed t z p- symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ekp1 - Ekpz2) ) )
def check_t_pz(L, dtype, Nup=None): hx = random() * 0.0 hz = random() * 0.0 J = random() h1 = [[hx, i] for i in range(L)] J1 = [[J, i, (i + 1) % L] for i in range(L)] h2 = [[hz * (-1) ** i, i] for i in range(L)] if type(Nup) is int: static = [["zz", J1], ["xx", J1], ["yy", J1], ["z", h2]] else: static = [["x", h1], ["z", h2], ["zz", J1]] if dtype is np.float32: kdtype = np.complex64 elif dtype is np.float64: kdtype = np.complex128 else: kdtype = dtype a = 2 L_2 = int(L / (a * 2)) for kblock in range(-L_2 + 1, 0): Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=kdtype, kblock=kblock, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pzblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pzblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() if norm(Ek - Ek1) > Ns * eps(dtype): raise Exception( "test failed t pz+ symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ek - Ek1) ) ) if norm(Ek - Ek2) > Ns * eps(dtype): raise Exception( "test failed t pz- symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ek - Ek2) ) ) Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=kdtype, kblock=0, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=0, pzblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=0, pzblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() Ekp = np.append(Ek1, Ek2) Ekp.sort() if norm(Ek - Ekp) > Ns * eps(dtype): raise Exception( "test failed t pz symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, 0, np.dtype(dtype), Nup, norm(Ek - Ekp) ) ) if (L / a) % 2 == 0: for kblock in range(1, L_2): Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=kdtype, kblock=kblock, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pzblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pzblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() if norm(Ek - Ek1) > Ns * eps(dtype): raise Exception( "test failed t pz+ symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ek - Ek1) ) ) if norm(Ek - Ek2) > Ns * eps(dtype): raise Exception( "test failed t pz- symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ek - Ek2) ) ) Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=kdtype, kblock=L_2, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=L_2, pzblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=L_2, pzblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() Ekp = np.append(Ek1, Ek2) Ekp.sort() if norm(Ek - Ekp) > Ns * eps(dtype): raise Exception( "test failed t pz symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, int(L / 2), np.dtype(dtype), Nup, norm(Ek - Ekp) ) ) else: for kblock in range(1, L_2 + 1): Hk = hamiltonian(static, [], N=L, Nup=Nup, dtype=kdtype, kblock=kblock, a=a) Ns = Hk.Ns Ek = Hk.eigvalsh() Hk1 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pzblock=+1, a=a) Hk2 = hamiltonian(static, [], N=L, Nup=Nup, dtype=dtype, kblock=kblock, pzblock=-1, a=a) Ek1 = Hk1.eigvalsh() Ek2 = Hk2.eigvalsh() if norm(Ek - Ek1) > Ns * eps(dtype): raise Exception( "test failed t pz+ symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ek - Ek1) ) ) if norm(Ek - Ek2) > Ns * eps(dtype): raise Exception( "test failed t pz- symmetry at L={0:3d} kblock={1:3d} with dtype {2} and Nup={3} {4}".format( L, kblock, np.dtype(dtype), Nup, norm(Ek - Ek2) ) )
basis = spin_basis_1d(L) basis2 = spin_basis_1d(L,Nup=L//2,kblock=0,pblock=1,zblock=1) J_zz = [[1.0,i,(i+1)%L] for i in range(0,L)] J_xy = [[0.5,i,(i+1)%L] for i in range(0,L)] static = [["+-",J_xy],["-+",J_xy],["zz",J_zz]] dynamic=[] for _i in dtypes.keys(): dtype = dtypes[_i] atol = atols[_i] H=hamiltonian(static,dynamic,basis=basis,dtype=dtype,check_herm=False,check_symm=False) H2=hamiltonian(static,dynamic,basis=basis2,dtype=dtype,check_herm=False,check_symm=False,check_pcon=False) Proj = basis2.get_proj(dtype) H_proj = project_op(H.tocsr(),Proj,dtype=dtype)['Proj_Obs'] H_proj2 = project_op(H,basis2,dtype=dtype)['Proj_Obs'] H_proj3 = project_op(H.tocsr(),basis2,dtype=dtype)['Proj_Obs'] H_proj4 = project_op(H,Proj,dtype=dtype)['Proj_Obs'] np.testing.assert_allclose(H_proj.todense(),H_proj2.todense(),atol=atol,err_msg='Failed projectors comparison!') np.testing.assert_allclose(H_proj3.todense(),H_proj4.todense(),atol=atol,err_msg='Failed projectors comparison!') np.testing.assert_allclose(H_proj.todense(),H_proj3.todense(),atol=atol,err_msg='Failed projectors comparison!') H2_proj = project_op(H2.tocsr(),Proj,dtype=dtype)['Proj_Obs']
def test_ops(): for L in range(1,5): Jz = [[1.0,i,(i+1)] for i in range(L-1)] Jx = [[2.0,i,(i+1)] for i in range(L-1)] Jy = [[3.0,i,(i+1)] for i in range(L-1)] operator_list = [["zz",Jz],["xx",Jx],["yy",Jy]] basis = spin_basis_1d(L,kblock=1,pblock=1) if basis.Ns > 0: for dtype in dtypes: H = hamiltonian(operator_list,[],basis=basis,dtype=dtype,check_symm=False,check_herm=False,check_pcon=False) H_op = HamiltonianOperator(operator_list,basis,dtype=dtype,check_symm=False,check_herm=False,check_pcon=False) v = np.random.randint(3,size=(H.Ns,)).astype(dtype) yield check_dot,H,H_op,v yield check_dot,H.T,H_op.T,v yield check_dot,H.H,H_op.H,v yield check_dot,H.conj(),H_op.conj(),v yield check_rdot,H,H_op,v yield check_rdot,H.T,H_op.T,v yield check_rdot,H.H,H_op.H,v yield check_rdot,H.conj(),H_op.conj(),v v = np.random.randint(3,size=(H.Ns,10)).astype(dtype) yield check_dot,H,H_op,v yield check_dot,H.T,H_op.T,v yield check_dot,H.H,H_op.H,v yield check_dot,H.conj(),H_op.conj(),v v = np.random.randint(3,size=(10,H.Ns)).astype(dtype) yield check_rdot,H,H_op,v yield check_rdot,H.T,H_op.T,v yield check_rdot,H.H,H_op.H,v yield check_rdot,H.conj(),H_op.conj(),v v = np.random.randint(3,size=(H.Ns,1)).astype(dtype) v = sp.csr_matrix(v) yield check_dot,H,H_op,v yield check_dot,H.T,H_op.T,v yield check_dot,H.H,H_op.H,v yield check_dot,H.conj(),H_op.conj(),v yield check_rdot,H,H_op,v.T yield check_rdot,H.T,H_op.T,v.T yield check_rdot,H.H,H_op.H,v.T yield check_rdot,H.conj(),H_op.conj(),v.T v = np.random.randint(3,size=(H.Ns,10)).astype(dtype) v = sp.csr_matrix(v) yield check_dot,H,H_op,v yield check_dot,H.T,H_op.T,v yield check_dot,H.H,H_op.H,v yield check_dot,H.conj(),H_op.conj(),v v = np.random.randint(3,size=(10,H.Ns)).astype(dtype) v = sp.csr_matrix(v) yield check_rdot,H,H_op,v yield check_rdot,H.T,H_op.T,v yield check_rdot,H.H,H_op.H,v yield check_rdot,H.conj(),H_op.conj(),v v = np.random.randint(3,size=(H.Ns,H.Ns)).astype(dtype) yield check_mul,H,H_op,v yield check_mul,H.T,H_op.T,v yield check_mul,H.H,H_op.H,v yield check_mul,H.conj(),H_op.conj(),v
"complex64":1E-4,"complex128":1E-13,"complex256":1E-13} L=10 basis = spin_basis_1d(L,kblock=0,pblock=1,zblock=1) J_zz = [[1.0,i,(i+1)%L,(i+2)%L] for i in range(0,L)] J_xy = [[1.0,i,(i+1)%L] for i in range(0,L)] # static and dynamic lists static_pm = [["+-",J_xy],["-+",J_xy]] static_zxz = [["zxz",J_zz]] for _i in dtypes.keys(): dtype = dtypes[_i] atol = atols[_i] # build Hamiltonian O_pm=hamiltonian(static_pm,[],basis=basis,dtype=dtype,check_herm=False,check_symm=False) O_zxz = hamiltonian(static_zxz,[],basis=basis,dtype=dtype,check_herm=False,check_symm=False) # H1=O_pm+O_zxz H2=O_pm-O_zxz # diagonalise H E1,V1 = H1.eigh() E2,V2 = H2.eigh() psi0=V1[:,0] rho0=np.outer(psi0.conj(),psi0) alpha=uniform(5) DE_args={"densities":randint(2),"alpha":uniform(5),"rho_d":True,"Srdm_args":{"basis":basis}}
J_xy = [[Jxy,i,(i+1)%L] for i in range(0,L)] J_yy = [[Jyy,i,(i+1)%L] for i in range(0,L)] # static and dynamic lists static_pm = [["+-",J_xy],["-+",J_xy]] static_yy = [["yy",J_yy]] dynamic_zz = [["zz",J_zz,time_dep,drive_args]] dynamic_zxz = [["zxz",J_zxz,drive,drive_args]] t=np.linspace(0.0,2.0,20) for _i in dtypes.keys(): dtype = dtypes[_i] atol = atols[_i] rtol = rtols[_i] H=hamiltonian(static_pm,dynamic_zxz,basis=basis,dtype=dtype,check_herm=False,check_symm=False) Ozz=hamiltonian([],dynamic_zz,basis=basis,dtype=dtype,check_herm=False,check_symm=False) H2=hamiltonian(static_yy,[],basis=basis,dtype=dtype,check_herm=False,check_symm=False) _,psi0 = H.eigsh(time=0,k=1,sigma=-100.0) psi0=psi0.squeeze() psi_t=H.evolve(psi0,0.0,t,iterate=True,rtol=solver_rtol,atol=solver_atol) psi_t2=H.evolve(psi0,0.0,t,rtol=solver_rtol,atol=solver_atol) Obs_list = {"Ozz_t":Ozz,"Ozz":Ozz(time=np.sqrt(np.exp(0.0)) )} Sent_args={'basis':basis,'chain_subsys':range( L//2 )} Obs = obs_vs_time(psi_t,t,Obs_list,return_state=True,Sent_args=Sent_args) Obs2 = obs_vs_time(psi_t2,t,Obs_list,return_state=True,Sent_args=Sent_args)
# static and dynamic lists for time-dep H static=[["zz",J_nn],["z",z_field],["x",x_field_pos]] dynamic=[["zz",J_nn,drive,drive_args], ["z",z_field,drive,drive_args],["x",x_field_neg,drive,drive_args]] # static and dynamic lists for step drive static1=[["zz",J_nn],["z",z_field]] static2=[["x",x_field_pos]] # loop over dtypes for _i in dtypes.keys(): dtype = dtypes[_i] atol = atols[_i] # compute Hamiltonians H=0.5*hamiltonian(static,dynamic,dtype=dtype,basis=basis) H1=hamiltonian(static1,[],dtype=dtype,basis=basis) H2=hamiltonian(static2,[],dtype=dtype,basis=basis) # ##### define time vector of stroboscopic times with 100 cycles ##### t=Floquet_t_vec(Omega,100,len_T=1) # t.vals=times, t.i=init. time, t.T=drive period # ##### calculate exact Floquet eigensystem ##### t_list=np.array([0.0,t.T/4.0,3.0*t.T/4.0])+np.finfo(float).eps # times to evaluate H dt_list=np.array([t.T/4.0,t.T/2.0,t.T/4.0]) # time step durations to apply H for ### # call Floquet class for evodict a coutinous H from a Hamiltonian object Floq_Hevolve=Floquet({'H':H,'T':t.T,'atol':1E-16,'rtol':1E-16},n_jobs=2) EF_Hevolve=Floq_Hevolve.EF # read off quasienergies