def test_F2_F1_christoffel(self):
'''-1j<d_id_j ψ|H|ψ>=<d_id_j ψ|Ad_j|d_jψ> with no truncation'''
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
from numpy import nonzero, logical_not as lon, max
for m, L in enumerate(range(2, 8)):
H = [Sz1@Sz2+(Sz1+Sz2) for _ in range(L-1)]
mps = self.fixtures[m].right_canonicalise(1).grow(H, 0.1, 2**L)
mps.right_canonicalise()
#mps = fMPS().random(L, 2, 2**L).right_canonicalise()
dA_dt = mps.dA_dt(H)
l, r = mps.get_envs()
def inv_diag(mat):
return diag(1/diag(mat))
def ch_diag(mat):
return diag(sqrt(diag(mat)))
cr, cl = [ch_diag(r(i)) for i in range(mps.L)], [ch_diag(l(i)) for i in range(mps.L)]
icr, icl = [inv_diag(cr[i]) for i in range(mps.L)], [inv_diag(cl[i]) for i in range(mps.L)]
inv_envs= (icr, icl, cr, cl)
for i, j in product(range(L), range(L)):
F2 = -1j*mps.F2(i, j, H, inv_envs=inv_envs)
Γ2 = mps.christoffel(i, j, min(i, j), closed=(None, None, l(min(i, j)-1)@dA_dt[min(i, j)]@r(min(i, j))))
self.assertTrue(allclose(F2, -Γ2))
def test_jac_no_projection(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_3.left_canonicalise()
H = [Sz1@Sz2+Sx1, Sz1@Sz2+Sx1+Sx2]
J1, J2, F = mps.jac(H, True, False)
J2 = J2+F
self.assertTrue(allclose(J1+J1.conj().T, 0))
from numpy import nonzero
for L in range(2, 7):
mps = fMPS().random(L, 2, 2**L).left_canonicalise()
N = 10
for _ in range(N):
H = [randn(4, 4)+1j*randn(4, 4) for _ in range(L-1)]
H = [h+h.conj().T for h in H]
J1, J2, F = mps.jac(H, True, False)
J2 = J2+F
self.assertTrue(allclose(J1,-J1.conj().T))
J2[abs(J2)<1e-10]=0
if not allclose(J2, 0):
print(J2[nonzero(J2)])
self.assertTrue(allclose(J2, 0))
#J = mps.jac(H)
#self.assertTrue(allclose(J+J.T, 0))
mps = (mps+mps.dA_dt(H)*0.1).left_canonicalise()
def test_local_hamiltonians_2(self):
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_2
listH = [Sz12@Sz22+Sx12+Sx22]
fullH = listH[0]
self.assertTrue(mps.dA_dt(listH, fullH=False)==mps.dA_dt(fullH, fullH=True))
def test_lyapunov_no_truncate_3(self):
"""zero lyapunov exponents with no truncation"""
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_3
H = [Sz1 @ Sz2 + Sx1 + Sx2, Sz1 @ Sz2 + Sx2]
T = linspace(0, 0.1, 100)
exps, lys, _ = Trajectory(mps, H).lyapunov(T, D=None)
self.assertTrue(allclose(exps[-1], 0))
def test_lyapunov_local_hamiltonian_3(self):
"""zero lyapunov exponents with local hamiltonian"""
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_3
H = [Sx1 + Sx2, Sx2]
T = linspace(0, 1, 100)
exps, lys, _ = Trajectory(mps, H).lyapunov(T, D=1)
self.assertTrue(allclose(exps[-1], 0))
def test_import_extract_tangent_vector(self):
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_4
H = [Sz12@Sz22+Sx12, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx22]
dA = mps.dA_dt(H)
dA_ = mps.import_tangent_vector(mps.extract_tangent_vector(dA))
self.assertTrue(dA==dA_)
def test_grow(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_4.left_canonicalise(1)
H = [Sx1@Sx2+Sy1@Sy2+Sz1@Sz2]*3
for D in [1, 2, 3, 4]:
A = mps.copy().grow(H, 0.1, D)
self.assertTrue(A.D == D)
A = mps.copy().grow(H, 0.1, 5)
self.assertTrue(A.D == 4)
def test_time_evolution(self):
"""test_time_evolution"""
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
H = [Sz1@Sz2+Sx1+Sx2]
T = linspace(0, 0.1, 2)
A = self.tfd_0_2
evs = []
for _ in range(400):
evs.append(A.Es([Sx, Sy, Sz], 1))
A = (A+A.dA_dt(H)*0.1).left_canonicalise()
def test_ddA_dt(self):
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_2
eyeH = [eye(4)]
dt = 0.1
Z = [randn(3)+1j*randn(3) for _ in range(10)]
for z in Z:
self.assertTrue(allclose(mps.ddA_dt(z, eyeH), -1j*z))
def test_local_hamiltonians_3(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 3)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 3)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 3)
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_3
listH = [Sz12@Sz22+Sx12, Sz12@Sz22+Sx12+Sx22]
fullH = sum([n_body(a, i, len(listH), d=2) for i, a in enumerate(listH)], axis=0)
self.assertTrue(mps.dA_dt(listH, fullH=False)==mps.dA_dt(fullH, fullH=True))
def test_F2_F1(self):
'''<d_id_j ψ|H|ψ>, <d_iψ|H|d_jψ>'''
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 6)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 6)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 6)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 6)
Sx5, Sy5, Sz5 = N_body_spins(0.5, 5, 6)
Sx6, Sy6, Sz6 = N_body_spins(0.5, 6, 6)
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_6.left_canonicalise()
listH = [Sz12@Sz22+Sx12, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx22+Sx12+Sx22, Sz12@Sz22+Sz12+Sx22, Sz12@Sz22+Sx22]
eyeH = [(1/(mps.L-1))*eye(4) for _ in range(5)]
fullH = Sz1@Sz2+Sz2@Sz3+Sz3@Sz4+Sz4@Sz5+Sz5@Sz6+Sx1+Sx2+Sx3+Sx4+Sx5+Sx6
for i, j in product(range(mps.L), range(mps.L)):
## F2 = <d_id_j ψ|H|ψ>
# zero for H = I
self.assertTrue(allclose(mps.F2(i, j, eyeH, testing=True), 0))
# Test gauge projectors are in the right place
mps.right_canonicalise()
l, r = mps.get_envs()
z1 = ncon([mps.F2(i, j, listH, testing=True), l(i-1)@c(mps[i])], [[1, 2, 3, -1, -2, -3], [1, 2, 3]])
z2 = ncon([mps.F2(i, j, listH, testing=True), l(j-1)@c(mps[j])], [[-1, -2, -3, 1, 2, 3], [1, 2, 3]])
self.assertTrue(allclose(z1, 0))
self.assertTrue(allclose(z2, 0))
mps.left_canonicalise()
l, r = mps.get_envs()
z1 = ncon([mps.F2(i, j, listH, testing=True), l(i-1)@c(mps[i])], [[1, 2, 3, -1, -2, -3], [1, 2, 3]])
z2 = ncon([mps.F2(i, j, listH, testing=True), l(j-1)@c(mps[j])], [[-1, -2, -3, 1, 2, 3], [1, 2, 3]])
self.assertTrue(allclose(z1, 0))
self.assertTrue(allclose(z2, 0))
## F1 = <d_iψ|H|d_jψ>
# For H = I: should be equal to δ_{ij} pr(i)
if i!=j:
self.assertTrue(allclose(mps.F1(i, j, eyeH, testing=True), 0))
if i==j:
b = mps.F1(i, j, eyeH, testing=True)
a = ncon([mps.left_null_projector(i), inv(r(i))], [[-1, -2, -4, -5], [-3, -6]])
self.assertTrue(allclose(a, b))
# Test gauge projectors are in the right place
mps.left_canonicalise()
l, r = mps.get_envs()
z1 = td(mps.F1(i, j, listH, testing=True), l(i-1)@c(mps[i]), [[0, 1, 2], [0, 1, 2]])
z1 = td(mps.F1(i, j, listH, testing=True), l(j-1)@mps[j], [[3, 4, 5], [0, 1, 2]])
self.assertTrue(allclose(z1, 0))
self.assertTrue(allclose(z2, 0))
mps.right_canonicalise()
l, r = mps.get_envs()
z1 = td(mps.F1(i, j, listH, testing=True), l(i-1)@c(mps[i]), [[0, 1, 2], [0, 1, 2]])
z1 = td(mps.F1(i, j, listH, testing=True), l(j-1)@mps[j], [[3, 4, 5], [0, 1, 2]])
self.assertTrue(allclose(z1, 0))
self.assertTrue(allclose(z2, 0))
def test_match_gauge_to(self):
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps_1 = self.right_cases[0]
# doesn't change expectation values
for case in self.right_cases:
a = mps_1.E(Sx, 0)
mps_1.right_canonicalise().match_gauge_to(case)
b = mps_1.E(Sx, 0)
self.assertTrue(allclose(a, b))
mps_1 = self.left_cases[0]
for case in self.left_cases:
a = mps_1.E(Sx, 0)
mps_1.left_canonicalise().match_gauge_to(case)
b = mps_1.E(Sx, 0)
self.assertTrue(allclose(a, b))
mps_1 = self.left_cases[0]
for case in self.right_cases:
a = mps_1.E(Sx, 0)
mps_1.left_canonicalise().match_gauge_to(case)
b = mps_1.E(Sx, 0)
self.assertTrue(allclose(a, b))
evs = []
evs_ = []
mps_0 = fMPS().random(6, 2, 5)
H = [
Sz12 @ Sz22 + Sx12 + Sx22, Sz12 @ Sz22 + Sx22,
Sz12 @ Sz22 + Sx22 + Sx22, Sz12 @ Sz22 + Sx22, Sz12 @ Sz22 + Sx22
]
mps = mps_0.copy()
for _ in range(30):
evs.append(mps.E_(Sx, 0))
old_mps = mps.copy()
mps = (mps + mps.dA_dt(H) * 0.1).left_canonicalise()
mps = mps.match_gauge_to(old_mps).copy()
mps = mps_0.copy()
for _ in range(30):
evs_.append(mps.E_(Sx, 0))
mps = (mps + mps.dA_dt(H) * 0.1).left_canonicalise()
self.assertTrue(allclose(array(evs), array(evs_)))
def test_local_hamiltonians_7(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 7)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 7)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 7)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 7)
Sx5, Sy5, Sz5 = N_body_spins(0.5, 5, 7)
Sx6, Sy6, Sz6 = N_body_spins(0.5, 6, 7)
Sx7, Sy7, Sz7 = N_body_spins(0.5, 7, 7)
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_7
listH = [Sz12@Sz22+Sx12, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx22]
fullH = sum([n_body(a, i, len(listH), d=2) for i, a in enumerate(listH)], axis=0)
self.assertTrue(mps.dA_dt(listH, fullH=False)==mps.dA_dt(fullH, fullH=True))
def test_random_with_energy(self):
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
L = 6
d = 2
D = 1
h = 4*Sz12@Sz22+2*Sx22+2*Sz22
h = (h+h.conj().T)/2
H = [h for _ in range(L-1)]
H[0] = H[0]+2*Sx12+2*Sz12
comH = sum([n_body(a, i, len(H), d=2) for i, a in enumerate(H)], axis=0)
v = eigvalsh(comH)
E = (max(v)-min(v))/2.5
tol = 1e-10
mps = fMPS().random_with_energy_E(E, H, L, d, D, 1e-10)
self.assertTrue(abs(mps.energy(H)-E)<tol)
def test_stop_resume(self):
"""test_stop_resume"""
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
dt, t_fin = 2e-2, 5
T = linspace(0, t_fin, int(t_fin // dt) + 1)
mps_0 = self.mps_0_4.right_canonicalise(3)
H = [Sz1 @ Sz2 + Sx1 + Sx2] + [Sz1 @ Sz2 + Sx2] + [Sz1 @ Sz2 + Sx2]
W = mps_0.L * [MPO_TFI(0, 0.25, 0.5, 0)]
F = Trajectory(mps_0, H=H, W=W)
F.run_name = 'test'
F.lyapunov(T, t_burn=0)
F.stop()
F_ = Trajectory().resume('test')
self.assertTrue(F_.mps_0 == F.mps_0)
self.assertTrue(F_.mps == F.mps)
self.assertTrue(allclose(F_.Q, F.Q))
self.assertTrue(allclose(F_.lys, F.lys))
self.assertTrue(
all([
allclose(F.vL[i], F_.mps.old_vL[i]) for i in range(len(F.vL))
]))
F_.lyapunov(T)
self.assertTrue(len(F_.lys) == 2 * len(T) - 1)
plt.plot(F.vs + F_.vs)
plt.show()
plt.plot(F_.lys)
plt.show()
plt.plot(F.mps_history + F_.mps_history)
plt.show()
shutil.rmtree(F_.run_dir)
def test_OTOCs_eye(self):
"""OTOC zero for W=eye"""
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 5)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 5)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 5)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 5)
Sx5, Sy5, Sz5 = N_body_spins(0.5, 5, 5)
mps = fMPS().random(5, 2, None).left_canonicalise()
W = mps.L * [MPO_TFI(0, 0.25, 0.5, 0.5)]
H = Sz1@Sz2+Sz2@Sz3+Sz3@Sz4+Sz4@Sz5+\
Sx1+Sx2+Sx3+Sx4+Sx5+\
Sz1+Sz2+Sz3+Sz4+Sz5
ops = eye(2**5), eye(2**5)
ops_ = ((eye(2), 0), (eye(2), 0))
T = linspace(0, 1, 3)
F = Trajectory(mps, H=H, W=W)
ed_evs = F.ed_OTOC(T, ops)
mps_evs = F.mps_OTOC(T, ops_)
plt.plot(mps_evs)
plt.show()
self.assertTrue(allclose(ed_evs, 0))
self.assertTrue(allclose(mps_evs, 0))
def test_dynamical_expand(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
# need to expand with 2 site heisenberg hamiltonian
from xmps.mps_examples import comp_z
H = [Sx1@Sx2+Sy1@Sy2+Sz1@Sz2]
# up down: must project
mps = comp_z(2).left_canonicalise()
self.assertTrue(not allclose(mps.projection_error(H, 0.1), 0))
# up up: no projection
mps = comp_z(1).left_canonicalise()
self.assertTrue(allclose(mps.projection_error(H, 0.1), 0))
# no need to expand with local hamiltonian
for D in [1, 2, 3]:
H = [Sx1+Sx2+Sy1+Sy2+Sz1+Sz2]*3
mps = self.mps_0_4.left_canonicalise(D)
self.assertTrue(allclose(mps.projection_error(H, 0.1), 0))
pre_struc = mps.structure()
mps.dynamical_expand(H, 0.1, 2*D)
post_struc = mps.structure()
self.assertTrue(pre_struc==post_struc)
# need to expand with 4 site heisenberg hamiltonian
H = [Sx1@Sx2+Sy1@Sy2+Sz1@Sz2]*3
D = 1
mps = self.mps_0_4.left_canonicalise(D)
pre_struc = mps.structure()
mps.dynamical_expand(H, 0.1, 2*D)
post_struc = mps.structure()
self.assertTrue(pre_struc!=post_struc)
def test_OTOCs_ed(self):
"""test mps otocs against ed"""
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 5)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 5)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 5)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 5)
Sx5, Sy5, Sz5 = N_body_spins(0.5, 5, 5)
mps = fMPS().random(5, 2, None).left_canonicalise()
W = mps.L * [MPO_TFI(0, 0.25, 0.5, 0.5)]
H = Sz1@Sz2+Sz2@Sz3+Sz3@Sz4+Sz4@Sz5+\
Sx1+Sx2+Sx3+Sx4+Sx5+\
Sz1+Sz2+Sz3+Sz4+Sz5
ops = Sz2, Sz5
ops_ = ((Sz, 1), (Sz, 4))
T = linspace(0, 1, 3)
F = Trajectory(mps, H=H, W=W, fullH=True)
ed_evs = F.ed_OTOC(T, ops)
mps_evs = F.mps_OTOC(T, ops_)
plt.plot(mps_evs)
plt.plot(ed_evs)
plt.show()
self.assertTrue(allclose(ed_evs, 0))
self.assertTrue(allclose(mps_evs, 0))
def test_local_energy(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 4)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 4)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 4)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 4)
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
mps = self.mps_0_4
listH = [Sz12@Sz22+Sx12, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx22]
fullH = Sz1@Sz2+Sz2@Sz3+Sz3@Sz4+Sx1+Sx2+Sx3+Sx4
self.assertTrue(isclose(mps.energy(listH, fullH=False), mps.energy(fullH, fullH=True)))
def test_local_recombine(self):
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 4)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 4)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 4)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 4)
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
listH4 = [Sz12@Sz22+Sx12, Sz12@Sz22+Sx12+Sx22, Sz12@Sz22+Sx22]
comH4 = sum([n_body(a, i, len(listH4), d=2) for i, a in enumerate(listH4)], axis=0)
fullH4 = Sz1@Sz2+Sz2@Sz3+Sz3@Sz4+Sx1+Sx2+Sx3+Sx4
self.assertTrue(allclose(fullH4, comH4))
import numpy as np
from xmps.iMPS import iMPS
from xmps.spin import paulis, N_body_spins
import matplotlib as mpl
import matplotlib.pyplot as plt
from tqdm import tqdm
#mpl.style.use('pub_fast')
X, Y, Z = paulis(0.5)
XI, YI, ZI = N_body_spins(0.5, 1, 2)
IX, IY, IZ = N_body_spins(0.5, 2, 2)
T = np.linspace(0, 1, 100)
dt = T[1] - T[0]
D = 10
mps = iMPS().random(2, D).left_canonicalise()
evs = []
H = -(XI @ IX + YI @ IY + ZI @ IZ)
for _ in tqdm(T):
k1 = mps.dA_dt([H]) * dt
k2 = (mps + k1 / 2).dA_dt([H]) * dt
k3 = (mps + k2 / 2).dA_dt([H]) * dt
k4 = (mps + k3).dA_dt([H]) * dt
mps = (mps + (k1 + 2 * k2 + 2 * k3 + k4) / 6).left_canonicalise()
evs.append(mps.Es(paulis(0.5)))
plt.plot(T, evs)
plt.scatter(T, evs, marker='x')
plt.savefig('evo.jpg')
#plt.show()
from xmps.spin import N_body_spins
from copy import copy
from itertools import product
import matplotlib as mp
import matplotlib.pyplot as plt
from xmps.tensor import H, C, r_eigenmatrix, l_eigenmatrix, get_null_space, p
from xmps.tensor import C as c, H as cT
from xmps.tensor import basis_iterator, T, rotate_to_hermitian, eye_like
from xmps.iMPS import iMPS, ivMPS, TransferMatrix, Map
from xmps.spin import spins
Sx, Sy, Sz = spins(0.5)
Sx12, Sy12, Sz12 = N_body_spins(0.5, 1, 2)
Sx22, Sy22, Sz22 = N_body_spins(0.5, 2, 2)
class TestMap(unittest.TestCase):
"""TestTransferMatrix"""
def setUp(self):
N = 10
D_min, D_max = 10, 11
d_min, d_max = 2, 3
p_min, p_max = 1, 2 # always 1 for now
self.rand_cases1 = [
iMPS().random(randint(d_min, d_max),
randint(D_min, D_max),
period=randint(p_min, p_max)) for _ in range(N)
]
def test_AAintegrators(self):
test_D_1_1 = False
if test_D_1_1:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mpss = {
2: self.mps_0_2,
3: self.mps_0_3,
4: self.mps_0_4,
5: self.mps_0_5
}
L = 3
mps_0 = mpss[L].left_canonicalise(1)
from xmps.Hamiltonians import Hamiltonian
J1, J2, h1, h2 = 0., 0.25, 0.5, 0.
Ham = Hamiltonian({'XX': J1, 'ZZ': J2, 'X': h1, 'Z': h2})
#H = Ham.to_matrices(L)
#H = [J2*4*Sz1@Sz2+J1*4*Sx1@Sx2+h1*2*(Sx1+Sx2)+h2*2*(Sz1+Sz2)] +\
# (L-2)*[J1*4*Sx1@Sx2+J2*4*Sz1@Sz2+h1*2*Sx2+h2*2*Sz2+h2*2*Sz2]
H = [Sz1 @ Sz2 + Sx1 + 0.5 * Sx2
] + (L - 2) * [Sz1 @ Sz2 + 0.5 * Sx1 + Sx2]
H_ = Ham.to_matrices(L)
#raise Exception
W = mps_0.L * [MPO_TFI(J1, J2, h1, h2)]
W_ = Ham.to_mpo(L)
F = Trajectory(mps_0, H=H, W=W)
F_ = Trajectory(mps_0, H=H_, W=W_)
dt, t_fin = 1e-2, 5
T = linspace(0, t_fin, int(t_fin // dt) + 1)
C = F.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
E = F_.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
F.clear()
F_.clear()
D = F.eulerint(T).mps_evs([Sx, Sy, Sz], 0)
Q = F_.eulerint(T).mps_evs([Sx, Sy, Sz], 0)
F.clear()
plot = True
if plot:
plt.plot(T, C)
plt.plot(T, D)
plt.plot(T, E, linestyle='--')
plt.plot(T, Q, linestyle='-.')
plt.savefig('test_trajs.pdf')
test_D_1_2 = False
if test_D_1_2:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mpss = {
2: self.mps_0_2,
3: self.mps_0_3,
4: self.mps_0_4,
5: self.mps_0_5
}
L = 4
mps_0 = mpss[L].left_canonicalise(1)
from xmps.Hamiltonians import Hamiltonian
J1, J2, h1, h2 = 0., 0.25, 0.5, 0.5
Ham = Hamiltonian({'XX': J1, 'ZZ': J2, 'X': h1, 'Z': h2})
H_ = Ham.to_matrices(L)
W = mps_0.L * [MPO_TFI(J1, J2, h1, h2)]
W_ = Ham.to_mpo(L)
F = Trajectory(mps_0, H=H_, W=W)
F_ = Trajectory(mps_0, H=H_, W=W_)
dt, t_fin = 1e-2, 5
T = linspace(0, t_fin, int(t_fin // dt) + 1)
C = F.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
E = F_.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
F_.clear()
Q = F_.eulerint(T).mps_evs([Sx, Sy, Sz], 0)
plot = True
if plot:
fig, ax = plt.subplots(2, 1, sharex=True)
ax[0].plot(T, C)
ax[0].plot(T, E, linestyle='--')
ax[0].plot(T, Q, linestyle='-.')
ax[1].plot(T, F.mps_energies())
ax[1].plot(T, F_.mps_energies())
plt.savefig('test_trajs.pdf')
test_D_2_1 = True
if test_D_2_1:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
mpss = {
2: self.mps_0_2,
3: self.mps_0_3,
4: self.mps_0_4,
5: self.mps_0_5
}
L = 3
mps_0 = mpss[L].left_canonicalise(2)
from xmps.Hamiltonians import Hamiltonian
J1, J2, h1, h2 = 0., 0.25, 0.5, 0.5
Ham = Hamiltonian({'XX': J1, 'ZZ': J2, 'X': h1, 'Z': h2})
H_ = Ham.to_matrices(L)
W = mps_0.L * [MPO_TFI(J1, J2, h1, h2)]
W_ = Ham.to_mpo(L)
F = Trajectory(mps_0, H=H_, W=W)
F_ = Trajectory(mps_0, H=H_, W=W_)
dt, t_fin = 5e-3, 10
T = linspace(0, t_fin, int(t_fin // dt) + 1)
C = F.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
E = F_.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
F_.clear()
Q = F_.eulerint(T).mps_evs([Sx, Sy, Sz], 0)
plot = True
if plot:
fig, ax = plt.subplots(2, 1, sharex=True)
ax[0].plot(T, C)
ax[0].plot(T, E, linestyle='--')
ax[0].plot(T, Q, linestyle='-.')
ax[1].plot(T, F.mps_energies(), label='invfree')
ax[1].plot(T, F_.mps_energies(), label='euler')
plt.legend()
plt.savefig('test_trajs.pdf')
raise Exception
test_2 = False
if test_2:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
dt, t_fin = 2e-2, 10
T = linspace(0, t_fin, int(t_fin // dt) + 1)
mps_0 = self.mps_0_2.left_canonicalise(1)
H = [Sz1 @ Sz2 + Sx1 + Sx2]
W = mps_0.L * [MPO_TFI(0, 0.25, 0.5, 0)]
F = Trajectory(mps_0, H=H, W=W)
A = F.edint(T).ed_evs([Sx1, Sy1, Sz1])
F.clear()
B = F.eulerint(T).mps_evs([Sx, Sy, Sz], 0)
F.clear()
C = F.invfreeint(T).mps_evs([Sx, Sy, Sz], 0)
F.clear()
#self.assertTrue(norm(B-A)/prod(A.shape)<dt**2)
#self.assertTrue(norm(C-A)/prod(A.shape)<dt**2)
plot = True
if plot:
fig, ax = plt.subplots(1, 1, sharex=True, sharey=True)
ax.set_ylim([-1, 1])
ax.plot(T, A)
#ax.plot(T, B)
ax.plot(T, C)
plt.show()
test_3 = False
if test_3:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
dt, t_fin = 2e-2, 10
T = linspace(0, t_fin, int(t_fin // dt) + 1)
mps_0 = self.mps_0_3.right_canonicalise()
H = [Sz1 @ Sz2 + Sx1 + Sx2] + [Sz1 @ Sz2 + Sx2]
W = mps_0.L * [MPO_TFI(0, 0.25, 0.5, 0)]
F = Trajectory(mps_0, H=H, W=W)
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 3)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 3)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 3)
A = F.edint(T).ed_evs([Sx3, Sy3, Sz3])
F.clear()
B = F.eulerint(T).mps_evs([Sx, Sy, Sz], 2)
F.clear()
C = F.invfreeint(T).mps_evs([Sx, Sy, Sz], 2)
self.assertTrue(norm(B - A) / prod(A.shape) < dt**2)
self.assertTrue(norm(C - A) / prod(A.shape) < dt**2)
plot = False
if plot:
fig, ax = plt.subplots(1, 1, sharey=True, sharex=True)
ax.set_ylim([-1, 1])
ax.plot(T, A)
ax.plot(T, B)
ax.plot(T, C)
plt.show()
test_4 = False
if test_4:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
dt, t_fin = 1e-2, 4
T = linspace(0, t_fin, int(t_fin // dt) + 1)
mps_0 = self.mps_0_4.left_canonicalise(1)
H = [Sz1 @ Sz2 + Sx1 + Sx2] + 2 * [Sz1 @ Sz2 + Sx2]
W = mps_0.L * [MPO_TFI(0, 0.25, 0.5, 0)]
F = Trajectory(mps_0, H=H, W=W)
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 4)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 4)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 4)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 4)
X = F.edint(T)
A = X.ed_evs([Sx3, Sy3, Sz3])
A_e = X.ed_energies()
F.clear()
X = F.eulerint(T)
B = X.mps_evs([Sx, Sy, Sz], 2)
X.ed_history = array(
[mps.recombine().reshape(-1) for mps in X.mps_list()])
B_e = X.ed_energies()
F.clear()
X = F.invfreeint(T)
C = X.mps_evs([Sx, Sy, Sz], 2)
X.ed_history = array(
[mps.recombine().reshape(-1) for mps in X.mps_list()])
C_e = X.ed_energies()
#self.assertTrue(norm(B-A)/prod(A.shape)<dt)
#self.assertTrue(norm(C-A)/prod(A.shape)<dt**2)
plot = True
if plot:
fig, ax = plt.subplots(1, 1, sharey=True, sharex=True)
ax.set_ylim([-1, 1])
ax.plot(T, A)
ax.plot(T, B)
ax.plot(T, C)
plt.show()
#plt.plot(T, A_e, label='ed')
#plt.plot(T, B_e, label='euler')
#plt.plot(T, C_e, label='invfree')
#plt.legend()
#plt.show()
test_5 = False
if test_5:
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
dt, t_fin = 2e-2, 10
T = linspace(0, t_fin, int(t_fin // dt) + 1)
mps_0 = self.mps_0_5.right_canonicalise()
H = [Sz1 @ Sz2 + Sx1 + Sx2
] + [Sz1 @ Sz2 + Sx2] + [Sz1 @ Sz2 + Sx2] + [Sz1 @ Sz2 + Sx2]
W = mps_0.L * [MPO_TFI(0, 0.25, 0.5, 0)]
F = Trajectory(mps_0, H=H, W=W)
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 5)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 5)
Sx3, Sy3, Sz3 = N_body_spins(0.5, 3, 5)
Sx4, Sy4, Sz4 = N_body_spins(0.5, 4, 5)
Sx5, Sy5, Sz5 = N_body_spins(0.5, 5, 5)
X = F.invfreeint(T, 'low')
C = X.mps_evs([Sx, Sy, Sz], 1)
C_e = X.mps_energies()
X.ed_history = array(
[mps.recombine().reshape(-1) for mps in X.mps_list()])
C_e_ = X.ed_energies()
F.clear()
X = F.edint(T)
A = X.ed_evs([Sx2, Sy2, Sz2])
A_e = X.ed_energies()
F.clear()
X = F.eulerint(T)
B = X.mps_evs([Sx, Sy, Sz], 1)
B_e = X.mps_energies()
X.ed_history = [
mps.recombine().reshape(-1) for mps in X.mps_list()
]
B_e_ = X.ed_energies()
F.clear()
self.assertTrue(norm(B - A) / prod(A.shape) < dt)
self.assertTrue(norm(C - A) / prod(A.shape) < dt**2)
plot = False
if plot:
fig, ax = plt.subplots(1, 1, sharey=True, sharex=True)
ax.set_ylim([-1, 1])
ax.plot(T, A)
#ax.plot(T, B)
ax.plot(T, C)
plt.show()
fig, ax = plt.subplots(1, 1, sharey=True, sharex=True)
ax.plot(T, A_e, label='ed')
#ax.plot(T, B_e, label='euler')
#ax.plot(T, B_e_, label='euler_')
#ax.plot(T, C_e, label='invfree')
ax.plot(T, C_e_, label='invfree_')
plt.legend()
plt.show()
import unittest
from qmps.ground_state import *
from qmps.tools import unitary_to_tensor, random_circuit, random_full_rank_circuit
from scipy import integrate
import numpy as np
from numpy.random import randn
from xmps.iMPS import iMPS
from xmps.iOptimize import find_ground_state
from xmps.spin import N_body_spins
from scipy.linalg import norm
from tqdm import tqdm
Sx1, Sy1, Sz1 = N_body_spins(1/2, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(1/2, 2, 2)
import matplotlib.pyplot as plt
class TestGroundState(unittest.TestCase):
def setUp(self):
N = 3
self.xs = [randn(8, 8)+1j*randn(8, 8) for _ in range(N)]
self.As = [iMPS().random(2, 2).mixed() for _ in range(N)]
self.verbose=True
@unittest.skip('x')
def test_Hamiltonian_to_matrix(self):
J = -1
g = 1
H = np.array([[J,g/2,g/2,0],
[g/2,-J,0,g/2],
[g/2,0,-J,g/2],
from numpy import trace as tr, zeros, printoptions, tensordot, trace, save
from numpy import sign, block, sqrt, max, sort
from numpy.random import randn
from numpy.linalg import inv, svd, eig, eigvalsh
from numpy.linalg import det, qr
import numpy as np
from scipy.linalg import sqrtm, expm, norm, null_space as null, cholesky as ch
from scipy.sparse.linalg import expm_multiply, expm
from matplotlib import pyplot as plt
from functools import reduce
from copy import copy, deepcopy
from tqdm import tqdm
Sx, Sy, Sz = spins(0.5)
Sx1, Sy1, Sz1 = N_body_spins(0.5, 1, 2)
Sx2, Sy2, Sz2 = N_body_spins(0.5, 2, 2)
class TestTrajectory(unittest.TestCase):
"""TestF"""
def setUp(self):
"""setUp"""
fix_dir = 'fixtures/'
self.tens_0_2 = load(fix_dir + 'mat2x2.npy')
self.tens_0_3 = load(fix_dir + 'mat3x3.npy')
self.tens_0_4 = load(fix_dir + 'mat4x4.npy')
self.tens_0_5 = load(fix_dir + 'mat5x5.npy')
self.mps_0_1 = fMPS().left_from_state(
self.tens_0_2).right_canonicalise(1)
