def __init__(self, L, M1, M2, R, psi_dim, psi_dtype, psi_device):
cytnx.LinOp.__init__(self, "mv", psi_dim, psi_dtype, psi_device)
self.anet = cytnx.Network("projector.net")
self.anet.PutUniTensor("M2", M2)
self.anet.PutUniTensors(["L", "M1", "R"], [L, M1, R], False)
self.psi_shape = [
L.shape()[1],
M1.shape()[2],
M2.shape()[2],
R.shape()[1]
]
def Projector(psi, L, M1, M2, R):
''' psi is Tensor, while L,M1,M2,R are UniTensor.
Return: h|psi> (Tensor)'''
psi_p = cytnx.UniTensor(psi, 0) ## share memory, no copy
psi_p.reshape_(L.shape()[1], M1.shape()[2], M2.shape()[2], R.shape()[1])
anet = cytnx.Network("projector.net")
anet.PutUniTensor("M2", M2)
anet.PutUniTensors(["psi", "L", "M1", "R"], [psi_p, L, M1, R], False)
H_psi = anet.Launch(optimal=True).get_block_() # get_block_ without copy
H_psi.flatten_() # only change meta, without copy.
psi.flatten_() ## this just in case psi is something shared.
return H_psi
def optimize_psi(psivec, functArgs, maxit=2, krydim=4):
""" Lanczos method for finding smallest algebraic eigenvector of linear \
operator defined as a function"""
#print(eig_Lanczos)
#create network!
L, M1, M2, R = functArgs
pshape = [L.shape()[1], M1.shape()[2], M2.shape()[2], R.shape()[1]]
anet = cytnx.Network("projector.net")
anet.PutUniTensor("M2", M2)
anet.PutUniTensors(["L", "M1", "R"], [L, M1, R], False)
H = Hxx(anet, pshape, len(psivec))
energy, psivec = cytnx.linalg.Lanczos_ER(H,
maxiter=4,
CvgCrit=9999999999,
Tin=psivec,
max_krydim=krydim)
return psivec, energy[0].item()
# | | | | |
# ----- -----A*[0]-- -----A*[1]--
#
#
# L_AMAH.net file is used to contract the LR[i]
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
LR = [None for i in range(Nsites + 1)]
LR[0] = L0
LR[-1] = R0
for p in range(Nsites - 1):
s, A[p], vt = cytnx.linalg.Svd(A[p])
A[p + 1] = cytnx.Contract(cytnx.Contract(s, vt), A[p + 1])
#A[p+1].print_diagram()
#A[p].print_diagram()
anet = cytnx.Network("L_AMAH.net")
anet.PutUniTensors(["L", "A", "A_Conj", "M"],
[LR[p], A[p], A[p].Conj(), M],
is_clone=False)
LR[p + 1] = anet.Launch(optimal=True)
_, A[-1] = cytnx.linalg.Svd(A[-1], is_U=True, is_vT=False) ## last one.
## DMRG sweep
## Now we are ready for sweeping procedure!
##>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
Ekeep = []
for k in range(1, numsweeps + 2):
# a. Optimize from right-to-left:
import cytnx
N = cytnx.Network()
N.FromString(["A: 0;1,2",\
"B: 0;3,4",\
"C: 5;1,6",\
"D: 5;7,8",\
"TOUT: 2,3,4;6,7,8",\
"ORDER: (A,B),(C,D)"\
])
print(N)
]
for i in Ls1:
i.put_block(cy.ones(D))
Ls2 = [i.clone() for i in Ls1]
## gates:
eHu = cy.linalg.ExpH(Hu, -tau)
eHd = cy.linalg.ExpH(Hd, -tau)
## iterator:
Eup_old, Edown_old = 0, 0
cov = False
for i in range(maxit):
## first do up >>>>>>>>>>>>>>>>>>
Nup = cy.Network("up.net")
Nup.PutUniTensors(["A", "B", "C", "L2A", "L2B", "L2C", "eHu", "s1"],
[A, B, C, Ls2[0], Ls2[1], Ls2[2], eHu, s1])
T = Nup.Launch(True)
Nrm = cy.Contract(T, T).item()
T /= np.sqrt(Nrm)
#normalize for numerical stability.
A, B, C, s1, Ls1[0], Ls1[1], Ls1[2] = cy.linalg.Hosvd(
T, [2, 2, 2], True, True, [D, D, D])
## de-contract Ls'
Ls2[0].set_labels([-10, A.labels()[0]])
Ls2[0] = 1. / Ls2[0]
Ls2[1].set_labels([-11, B.labels()[0]])
Ls2[1] = 1. / Ls2[1]
Ls2[2].set_labels([-12, C.labels()[0]])
import cytnx
N = cytnx.Network("example.net")
print(N)
psi_T.reshape_(*shp)
psi = cytnx.UniTensor(psi_T, 2)
s0, A, B = cytnx.linalg.Svd_truncate(psi, min(chi, d)) ## Svd
s0 /= s0.get_block_().Norm().item() ## normalize
# absorb A[0], B[0] to left & right enviroment.
#
# L[1]: R[1]:
# ----A[0]-- --B[0]----
# | | | |
# L[0]--M---- ---M----R[0]
# | | | |
# ----A*[0]- -B*[0]----
#
anet = cytnx.Network("L_AMAH.net")
anet.PutUniTensors(["L", "A", "A_Conj", "M"], [L, A, A.Conj(), M],
is_clone=False)
L = anet.Launch(optimal=True)
anet = cytnx.Network("R_AMAH.net")
anet.PutUniTensors(["R", "B", "B_Conj", "M"], [R, B, B.Conj(), M],
is_clone=False)
R = anet.Launch(optimal=True)
## Construct n = 1
# 1) again, init a random psi as initial state with shape [d,d,d,d]
#
# (d)---[psi1]---(d)
# | |
# (d) (d)
#
