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_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_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_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 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_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_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 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_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 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_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 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_all = ent_entropy({'V_states': V}, basis, **Sent_args) return (S_pure, S_DM, S_all)
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 anneal_bath_4(L,Nb,T,gamma=0.2,omega=1.0,path="."): ti = time.time() filename = os.path.join(path,"spin_bath_exact_L_{}_Nb_{}_T_{}_gamma_{}_omega_{}.npz".format(L,Nb,T,gamma,omega)) if os.path.isfile(filename): print "file_exists...exiting run." exit() if Nb%2 == 1: S = "{}/2".format(Nb) else: S = "{}".format(Nb//2) print "creating basis" 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) print "L={}, H-space size: {}".format(L,basis.Ns) bath_energy=[[-omega/Nb,0,0]] SB_1_list = [[-gamma/Nb,i,0] for i in range(L)] SB_2_list = [[-gamma/np.sqrt(Nb),i,0] for i in range(L)] B_h_list = [[-1,0]] h_list = [[-1,i] for i in range(L)] J_list = [[-1,i,(i+1)%L] for i in range(L)] A = lambda t:(t/T)**2 B = lambda t:(1-t/T)**2 static = [ ["+|-",SB_2_list], ["-|+",SB_2_list], ] dynamic = [ ["x|",h_list,B,()], ["|+",B_h_list,B,()], ["|-",B_h_list,B,()], ["zz|",J_list,A,()], ["z|z",SB_1_list,A,()], ["|zz",bath_energy,A,()], ] print "creating hamiltonian" kwargs=dict(basis=basis,dtype=np.float64, check_symm=False,check_pcon=False,check_herm=False) H = hamiltonian(static,dynamic,**kwargs) print "solving initial state" E0,psi_0 = H.eigsh(k=1,which="SA",time=0) psi_0 = psi_0.ravel() print "evolving" out = np.zeros(psi_0.shape,dtype=np.complex128) psi_f = evolve(psi_0,0,T,H._hamiltonian__omp_SO,f_params = (out,),solver_name="dop853",atol=1.1e-10,rtol=1.1e-10) print "saving" np.savez_compressed(filename,psi=psi_f) print "dome......{} sec".format(time.time()-ti)
def Hamiltonian_level_statistics(N, J_zz=0.0, J_xx=0.0, J_yy=0, J_xy=0.0, J_z=0.0, J_x=0.0, amplitudez=0.0, amplitudex=0.0, periodic=True, conserve=False, seed=100): np.random.seed(seed) L = N; if periodic==True: boundary = L; else: boundary = L-1; random_disorder_z = 4 * amplitudez * (np.random.rand(L) - 0.5); random_disorder_x = 4 * amplitudex * (np.random.rand(L) - 0.5); H_zz = [[J_zz,i,(i+1)%L] for i in range(boundary)] # PBC H_xx = [[J_xx,i,(i+1)%L] for i in range(boundary)] # PBC H_xy = [[J_xy,i,(i+1)%L] for i in range(boundary)] # PBC H_yy = [[J_yy,i,(i+1)%L] for i in range(boundary)] # PBC H_z = [[J_z + random_disorder_z[i],i] for i in range(L)] # PBC H_x = [[J_x + random_disorder_x[i],i] for i in range(L)] # PBC static=[["+-",H_xy],["-+",H_xy],["zz",H_zz],["xx",H_xx], ["yy",H_yy],["z",H_z],["x",H_x]]; dynamic=[]; if conserve==True: basis=spin_basis_1d(L=N, Nup=N//2); else: basis=spin_basis_1d(L=N); H=hamiltonian(static,dynamic,dtype=np.float64,basis=basis,check_herm=False); eig_vals = H.eigvalsh(); length = len(eig_vals) // 2; start = length - 25; end = length + 25; eig_vals = eig_vals[start:end] eig_vals_spacing = np.array([eig_vals[i+1] - eig_vals[i] for i in range(len(eig_vals) - 1)]); r_val = 0.0; size = len(eig_vals_spacing)-1; r_val_dist = np.zeros([size]); print(size); j=0; for i in range(size): val = np.min([eig_vals_spacing[i], eig_vals_spacing[i+1]]) / np.max([eig_vals_spacing[i], eig_vals_spacing[i+1]]); r_val_dist[i] = size; #print(val); if val > -0.1: r_val += val; j+=1; print(r_val/j); return r_val/j, r_val_dist;
def Ham(L): basis = spin_basis_1d(L) # static J_z = [[1.0, i, (i + 1) % L] for i in range(L)] # PBC Z = [[2.0, i] for i in range(L)] X = [[0.8, i] for i in range(L)] static = [["zz", J_z], ["z", Z], ["x", X]] #dynamic var def linear_ramp(t): global tau return t / tau def dries_ramp(t): global tau p = np.pi lambda_0 = 0.0 lambda_f = -10.0 return lambda_0 + (lambda_f - lambda_0) * np.sin( p / 2 * (np.sin(t * p / 2.0 / tau)**2))**2 ramp_args = [] s = np.zeros(L) s[0] = 1 J_x_t = [[s[j], j] for j in range(L - 1)] dynamic = [["x", J_x_t, dries_ramp, ramp_args]] # compute the time-dependent Heisenberg Hamiltonian H0 = hamiltonian(static, dynamic, basis=basis, dtype=np.complex_) return H0
def exact_diag(J1,J2,N,twoSz): ###### setting up bases ###### ## https://github.com/weinbe58/QuSpin/issues/324 basis_1d = spin_basis_1d(L=N,Nup=N//2+twoSz,S="1/2",pauli=0) ###### setting up hamiltonian ###### Jzzs = \ [[J1,i,(i+1)%N] for i in range(N)] \ + [[J2,i,(i+2)%N] for i in range(N)] Jpms = \ [[0.5*J1,i,(i+1)%N] for i in range(N)] \ + [[0.5*J2,i,(i+2)%N] for i in range(N)] Jmps = \ [[0.5*J1,i,(i+1)%N] for i in range(N)] \ + [[0.5*J2,i,(i+2)%N] for i in range(N)] static = [\ ["zz",Jzzs],["+-",Jpms],["-+",Jmps],\ ] # build hamiltonian # H = hamiltonian(static,[],static_fmt="csr",basis=basis_1d,dtype=np.float64) no_checks = dict(check_symm=False, check_pcon=False, check_herm=False) H = hamiltonian(static,[],static_fmt="csr",basis=basis_1d,dtype=np.float64,**no_checks) # diagonalise H sizeH = H.tocsr(time=0).shape[0] if sizeH > 100: # ene,vec = H.eigsh(time=0.0,which="SA",k=2) ene = H.eigsh(which="SA",k=20,return_eigenvectors=False); ene = np.sort(ene) # ene = H.eigsh(which="SA",k=1,return_eigenvectors=False) else: ene = H.eigvalsh() return ene
def del_lambda_Ham(L): basis = spin_basis_1d(L) hx_lamb=1.0 hx_lamb_arr = [[hx_lamb,i] for i in range(L)] static_lamb = [["x",hx_lamb_arr]] dynamic_lamb =[] op_lamb=hamiltonian(static_lamb,dynamic_lamb,basis=basis,dtype=np.float_,check_symm=False,check_herm=False) return op_lamb
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 run_entanglement_entropy(J_zz, J_z, J_x, couplings, initial_state="Haar", t_max=15, t_step=100, t_init=0, basis=None, seed=None, L=12, periodic=False): entanglement_entropy = np.zeros([len(couplings), t_step]) basis = spin_basis_1d(L=L + 1) init_psi = generate_initial_state(L + 1, initial_state=initial_state, seed=seed) t = np.linspace(t_init, t_max, t_step) if periodic: BC = 0 else: BC = 1 H_zz = [[J_zz, i, (i + 1) % L] for i in range(L - BC)] # PBC H_z = [[J_z, i] for i in range(L)] # PBC H_x = [[J_x, i] for i in range(L)] # PBC for coupling in range(len(couplings)): J_xxc, J_zc, J_xc = couplings[coupling], J_z, J_x H_xxc = [[J_xxc / np.sqrt(L), i, L] for i in range(L)] H_zc = [[J_zc, L]] H_xc = [[J_xc, L]] # define static and dynamics lists static = [["zz", H_zz], ["z", H_z], ["x", H_x], ["zz", H_xxc], ["z", H_zc], ["x", H_xc]] #static=[["zz",H_zz],["z",H_z],["x",H_x]]; dynamic = [] H = hamiltonian(static, dynamic, dtype=np.float64, basis=basis, check_herm=False) psi_t = H.evolve(init_psi, t_init, t) for i in range(len(t)): entanglement_entropy[coupling, i] = ((L + 1) // 2) * basis.ent_entropy( psi_t.T[i], sub_sys_A=range( (L + 1) // 2))["Sent_A"] return t_max, t_init, entanglement_entropy
def Ham_int_antiferro(L,hz): basis = spin_basis_1d(L) J=1.0 hz_arr = [[hz,i] for i in range(L)] # OBC J_arr =[[J,i,(i+1)%L] for i in range(L)] # PBC [[J,i,(i+1)] for i in range(L-1)] # OBC# # static and dynamic lists static = [["zz",J_arr],["x",hz_arr]] dynamic =[] H = hamiltonian(static,dynamic,basis=basis,dtype=np.float_,check_symm=False,check_herm=False) return H
def del_lambda_Ham(L): basis = spin_basis_1d(L) hx_lamb=-1.0 hx_lamb_arr=np.zeros(L) hx_lamb_arr[0]=hx_lamb hx_lamb_arr = [[hx_lamb_arr[i],i] for i in range(L)] # OBC static_lamb = [["z",hx_lamb_arr]] dynamic_lamb =[] op_lamb=hamiltonian(static_lamb,dynamic_lamb,basis=basis,dtype=np.complex_,check_symm=False,check_herm=False) return op_lamb
def Ham_int(L): basis = spin_basis_1d(L) hz=-5.0#(np.sqrt(5)+1)/4 #parameters used by Kim and Huse J=-1.0 hz_arr = [[hz,i] for i in range(L)] # OBC J_arr = [[1,i,(i+1)] for i in range(L-1)] # OBC[[J,i,(i+1)%L] for i in range(L)] # PBC # static and dynamic lists static = [["xx",J_arr],["z",hz_arr]] dynamic =[] H = hamiltonian(static,dynamic,basis=basis,dtype=np.complex_,check_symm=False,check_herm=False) return H
def exact_diag(Jleg1,Jleg2,Jleg3,Jleg4,Jrung,Dleg1,Dleg2,Dleg3,Dleg4,Drung,L,m,k,p): N = 2*L # number of sites ###### setting up bases ###### ## https://github.com/weinbe58/QuSpin/issues/324 # basis_1d = spin_basis_1d(L=N,m=m,S="1",pauli=0) basis_1d = spin_basis_1d(L=N,m=m,S="1",pauli=0,a=2,kblock=k,pblock=p) ###### setting up hamiltonian ###### Jzzs = \ [[Jleg1*Dleg1,i,(i+2)%N] for i in range(0,N,2)] \ + [[Jleg1*Dleg1,i,(i+2)%N] for i in range(1,N,2)] \ + [[Jleg2*Dleg2,i,(i+3)%N] for i in range(0,N,2)] \ + [[Jleg2*Dleg2,i,(i+1)%N] for i in range(1,N,2)] \ + [[Jleg3*Dleg3,i,(i+4)%N] for i in range(0,N,2)] \ + [[Jleg3*Dleg3,i,(i+4)%N] for i in range(1,N,2)] \ + [[Jleg4*Dleg4,i,(i+5)%N] for i in range(0,N,2)] \ + [[Jleg4*Dleg4,i,(i+3)%N] for i in range(1,N,2)] \ + [[Jrung*Drung,i,i+1] for i in range(0,N,2)] Jpms = \ [[0.5*Jleg1,i,(i+2)%N] for i in range(0,N,2)] \ + [[0.5*Jleg1,i,(i+2)%N] for i in range(1,N,2)] \ + [[0.5*Jleg2,i,(i+3)%N] for i in range(0,N,2)] \ + [[0.5*Jleg2,i,(i+1)%N] for i in range(1,N,2)] \ + [[0.5*Jleg3,i,(i+4)%N] for i in range(0,N,2)] \ + [[0.5*Jleg3,i,(i+4)%N] for i in range(1,N,2)] \ + [[0.5*Jleg4,i,(i+5)%N] for i in range(0,N,2)] \ + [[0.5*Jleg4,i,(i+3)%N] for i in range(1,N,2)] \ + [[0.5*Jrung,i,i+1] for i in range(0,N,2)] Jmps = \ [[0.5*Jleg1,i,(i+2)%N] for i in range(0,N,2)] \ + [[0.5*Jleg1,i,(i+2)%N] for i in range(1,N,2)] \ + [[0.5*Jleg2,i,(i+3)%N] for i in range(0,N,2)] \ + [[0.5*Jleg2,i,(i+1)%N] for i in range(1,N,2)] \ + [[0.5*Jleg3,i,(i+4)%N] for i in range(0,N,2)] \ + [[0.5*Jleg3,i,(i+4)%N] for i in range(1,N,2)] \ + [[0.5*Jleg4,i,(i+5)%N] for i in range(0,N,2)] \ + [[0.5*Jleg4,i,(i+3)%N] for i in range(1,N,2)] \ + [[0.5*Jrung,i,i+1] for i in range(0,N,2)] static = [\ ["zz",Jzzs],["+-",Jpms],["-+",Jmps],\ ] # build hamiltonian # H = hamiltonian(static,[],static_fmt="csr",basis=basis_1d,dtype=np.float64) no_checks = dict(check_symm=False, check_pcon=False, check_herm=False) H = hamiltonian(static,[],static_fmt="csr",basis=basis_1d,dtype=np.float64,**no_checks) # diagonalise H sizeH = H.tocsr(time=0).shape[0] if sizeH > 100: # ene,vec = H.eigsh(time=0.0,which="SA",k=2) # ene = H.eigsh(which="SA",k=2,return_eigenvectors=False); ene = np.sort(ene) ene = H.eigsh(which="SA",k=1,return_eigenvectors=False) else: ene = H.eigvalsh() return ene
def set_density_mat(self): """Builds Gibbs density matrix based on exchange coeffs and fields params: x,y,z - fields xx, yy, zz - couplings """ no_checks = { "check_herm": False, "check_pcon": False, "check_symm": False } static = [] for field in ['x', 'y', 'z']: if field in self.__dict__.keys(): fields_list = self.__dict__[field] fields_list = [[fields_list[i], i] for i in range(self.n_spins)] static.append([field, fields_list]) for coupling in ['xx', 'yy', 'zz']: if coupling in self.__dict__.keys(): couplings_list = self.__dict__[coupling] couplings_list = [[ couplings_list[i], i, (i + 1) % self.n_spins ] for i in range(self.n_spins - 1)] static.append([coupling, couplings_list]) basis = spin_basis_1d(self.n_spins) dynamic = [] # generating h_xamiltonian H = hamiltonian(static, dynamic, basis=basis, **no_checks) H = H.toarray() # normalization constant Z = np.trace(sp.linalg.expm(-self.beta * H)) # density matrix try: rho = sp.linalg.expm(-self.beta * H) / Z except RuntimeWarning: print('Error!') print(f"Z={Z}") print(f"Static={static}") print(f"H={H}") self.density_mat = rho return self.density_mat
def Ham_nonint(L): basis = spin_basis_1d(L) hz=(np.sqrt(5)+1)/4 #parameters used by Kim and Huse hx=(np.sqrt(5)+5)/8 J=1.0 hz_arr = [[hz,i] for i in range(L)] hx_arr = [[hx,i] for i in range(L)] J_arr =[[J,i,(i+1)] for i in range(L-1)] # OBC [[J,i,(i+1)%L] for i in range(L)] # PBC # static and dynamic lists static = [["zz",J_arr],["z",hz_arr], ["x",hx_arr] ] dynamic =[] H = hamiltonian(static,dynamic,basis=basis,dtype=np.float_,check_symm=False,check_herm=False) return H
def sigma(i, alpha, L, basis=None): """ Returns the sigma-alpha operator at site i, written out in basis <basis> (if not specified, uses spin_basis_1d with no symmetries applied) i = site index 0, ..., L-1 Allowed values for alpha: "x", "y", "z", "+", "-" """ if alpha not in SP_TYPES: raise TypeError("Invalid Spin index") if basis is None: basis = spin_basis_1d(L, pauli=True) static = [[alpha, [[1, i]]]] dynamic = [] return hamiltonian(static, dynamic, basis=basis)
def _product_state(self, align='ferro', H_vector='z', Sz_sector=None): '''Generate a product state along a particular vector direction on Bloch sphere. Parameters -------------- align : string determines whether the initial state is ferromagnetic, antiferromagnetic, or random H_vector : string vector on the bloch sphere along which the spins are (anti) aligned ***(Currently only allows {x,y, or z})*** Sz_sector : int Argument for QuSpin Spin Basis Constructor that defines the limited spin space for the basis states. Condition that N<L. Returns -------------- ps_state : numpy.ndarray Product state that is (anti)feromagnetically aligned. basis : quspin.basis.basis_1d.spin.spin_basis_1d Basis in which the state is represented. ''' basis = spin_basis1d(L=self.S, Nup=Sz_sector) pi_control = (-1)**(align == 'antiferro') #(Anti) align neighboring spins if align != 'random': H_field = [[1.0 * pi_control**i, i] for i in range(self.S)] #Magnetic field energies static = [[H_vector, H_field]] #Assign direction to magnetic field dynamic = [] basis = spin_basis_1d(L=self.S) H = hamiltonian(static, dynamic, dtype=np.float64, basis=basis) E_min, psi_0 = H.eigsh(k=self.S, which="SA") #Get ground state (A)FM product state ps_state = psi_0.T[0].reshape((-1, )) elif align == 'random': ps_state = rand_ket(2**self.S) return ps_state, basis
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): basisk1=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,pblock=+1) Hkp1=hamiltonian(static,[],dtype=dtype,basis=basisk1) basisk2=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,pblock=-1) Hkp2=hamiltonian(static,[],dtype=dtype,basis=basisk2) Ns=Hkp1.Ns Ekp1=Hkp1.eigvalsh() Ekp2=Hkp2.eigvalsh() basisk11=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,pblock=+1,zblock=+1) Hkpz11=hamiltonian(static,[],dtype=dtype,basis=basisk11) basisk12=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,pblock=+1,zblock=-1) Hkpz12=hamiltonian(static,[],dtype=dtype,basis=basisk12) Ekpz11=Hkpz11.eigvalsh() Ekpz12=Hkpz12.eigvalsh() Ekpz1=np.concatenate((Ekpz11,Ekpz12)) Ekpz1.sort() basisk21=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,pblock=-1,zblock=+1) Hkpz21=hamiltonian(static,[],dtype=dtype,basis=basisk21) basisk22=spin_basis_1d(L=L,Nup=Nup,kblock=kblock,pblock=-1,zblock=-1) Hkpz22=hamiltonian(static,[],dtype=dtype,basis=basisk22) 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_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]] basis=spin_basis_1d(L=L,pauli=False) H1=hamiltonian(static1,[],dtype=dtype,basis=basis) H2=hamiltonian(static2,[],dtype=dtype,basis=basis) 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 Ham(L): basis = spin_basis_1d(L) # static J_z = [[1.0, i, (i + 1) % L] for i in range(L)] # PBC Z = [[2.0, i] for i in range(L)] X = [[0.8, i] for i in range(L)] static = [["zz", J_z], ["z", Z], ["x", X]] #dynamic var def linear_ramp(t): global tau #print "tau:", tau #tau=1 return t / tau def dries_ramp(t): global tau pi = np.pi lambda_0 = 0.0 lambda_f = -10.0 return lambda_0 + (lambda_f - lambda_0) * np.sin( pi / 2 * (np.sin(t * pi / 2.0 / tau)**2))**2 def alpha_0(t_var): return 1.0 / (6 + (t_var + 0.8)**2) def CD_ramp(t): global tau return np_lambda_dot(t, tau) * alpha_0(t) ramp_args = [] s = np.zeros(L) s[0] = 1 J_x_t = [[s[j], j] for j in range(L - 1)] J_y_t = [[s[j], j] for j in range(L - 1)] dynamic = [["x", J_x_t, dries_ramp, ramp_args], ["y", J_y_t, CD_ramp, ramp_args]] # compute the time-dependent Heisenberg Hamiltonian H0 = hamiltonian(static, dynamic, basis=basis, dtype=np.complex_) #print J_z,'\n', Z, '\n', X #print "Ham \n", H0 return H0
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
import numpy as np from numpy.random import uniform,seed,shuffle,randint # pseudo random numbers seed() """ This test only makes sure the function 'diag_ensemble' runs properly. """ dtypes={"float32":np.float32,"float64":np.float64,"float128":np.float128, "complex64":np.complex64,"complex128":np.complex128,"complex256":np.complex256} atols={"float32":1E-4,"float64":1E-13,"float128":1E-13, "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
rtols={"float32":1E-4,"float64":1E-13,"complex64":1E-4,"complex128":1E-13} def drive(t): return np.exp(-0.2*t)*np.cos(1.7*t) drive_args=[] def time_dep(t): return np.cosh(+1.1*t)*np.cos(2.0*t) solver_atol = 1E-18 solver_rtol = 1E-18 L=10 basis = spin_basis_1d(L) Jzxz=uniform(3.0) Jzz=uniform(3.0) Jxy=uniform(3.0) Jyy=uniform(3.0) J_zxz =[[Jzxz,i,(i+1)%L,(i+2)%L] for i in range(0,L)] J_zz = [[Jzz,i,(i+1)%L] for i in range(0,L)] 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]]
for _r in range(10): # 10 random realisations ##### define model parameters ##### L=8 # system size J=1.0 # spin interaction g=uniform(0.2,1.5) # transverse field h=uniform(0.2,1.5) # parallel field Omega=uniform(5.0,10.0) # drive frequency # ##### set up alternating Hamiltonians ##### # define time-reversal symmetric periodic step drive def drive(t,Omega): return np.sign(np.cos(Omega*t)) drive_args=[Omega] # compute basis in the 0-total momentum and +1-parity sector basis=spin_basis_1d(L=L,a=1,kblock=0,pblock=1) # define PBC site-coupling lists for operators x_field_pos=[[+g,i] for i in range(L)] x_field_neg=[[-g,i] for i in range(L)] z_field=[[h,i] for i in range(L)] J_nn=[[J,i,(i+1)%L] for i in range(L)] # PBC # 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():
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
""" dtypes={"float32":np.float32, "float64":np.float64, # "float128":np.float128, "complex64":np.complex64, "complex128":np.complex128, # "complex256":np.complex256 } atols={"float32":1E-4,"float64":1E-13, "complex64":1E-4,"complex128":1E-13} L=16 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)