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)
