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
