def test_ED():
# just quickly check that it runs without errors for a small system
xxz_pars = dict(L=4, Jxx=1., Jz=1., hz=0.0, bc_MPS='finite')
M = XXZChain(xxz_pars)
ED = ExactDiag(M)
ED.build_full_H_from_mpo()
H, ED.full_H = ED.full_H, None
ED.build_full_H_from_bonds()
H2 = ED.full_H
assert (npc.norm(H - H2, np.inf) < 1.e-14)
ED.full_diagonalization()
psi = ED.groundstate()
print("select charge_sector =", psi.qtotal)
ED2 = ExactDiag(M, psi.qtotal)
ED2.build_full_H_from_mpo()
ED2.full_diagonalization()
psi2 = ED2.groundstate()
full_psi2 = psi.zeros_like()
full_psi2[ED2._mask] = psi2
ov = npc.inner(psi, full_psi2, do_conj=True)
print("overlab <psi | psi2> = 1. -", 1. - ov)
assert (abs(abs(ov) - 1.) < 1.e-15)
# starting from a random guess in the correct charge sector,
# check if we can also do lanczos.
np.random.seed(12345)
psi3 = npc.Array.from_func(np.random.random,
psi2.legs,
qtotal=psi2.qtotal,
shape_kw='size')
E0, psi3, N = lanczos(ED2, psi3)
print("Lanczos E0 =", E0)
ov = npc.inner(psi3, psi2, do_conj=True)
print("overlab <psi2 | psi3> = 1. -", 1. - ov)
assert (abs(abs(ov) - 1.) < 1.e-15)
def example_exact_diagonalization(L, Jz):
xxz_pars = dict(L=L, Jxx=1., Jz=Jz, hz=0.0, bc_MPS='finite')
M = XXZChain(xxz_pars)
product_state = ["up", "down"] * (xxz_pars['L'] // 2) # this selects a charge sector!
psi_DMRG = MPS.from_product_state(M.lat.mps_sites(), product_state)
charge_sector = psi_DMRG.get_total_charge(True) # ED charge sector should match
ED = ExactDiag(M, charge_sector=charge_sector, max_size=2.e6)
ED.build_full_H_from_mpo()
# ED.build_full_H_from_bonds() # whatever you prefer
print("start diagonalization")
ED.full_diagonalization() # the expensive part for large L
E0_ED, psi_ED = ED.groundstate() # return the ground state
print("psi_ED =", psi_ED)
print("run DMRG")
dmrg.run(psi_DMRG, M, {'verbose': 0}) # modifies psi_DMRG in place!
# first way to compare ED with DMRG: convert MPS to ED vector
psi_DMRG_full = ED.mps_to_full(psi_DMRG)
print("psi_DMRG_full =", psi_DMRG_full)
ov = npc.inner(psi_ED, psi_DMRG_full, axes='range', do_conj=True)
print("<psi_ED|psi_DMRG_full> =", ov)
assert (abs(abs(ov) - 1.) < 1.e-13)
# second way: convert ED vector to MPS
psi_ED_mps = ED.full_to_mps(psi_ED)
ov2 = psi_ED_mps.overlap(psi_DMRG)
print("<psi_ED_mps|psi_DMRG> =", ov2)
assert (abs(abs(ov2) - 1.) < 1.e-13)
assert (abs(ov - ov2) < 1.e-13)
# -> advantage: expectation_value etc. of MPS are available!
print("<Sz> =", psi_ED_mps.expectation_value('Sz'))
def test_dmrg_diag_method(engine, diag_method, tol=1.e-6):
bc_MPS = 'finite'
model_params = dict(L=6, S=0.5, bc_MPS=bc_MPS, conserve='Sz', verbose=0)
M = SpinChain(model_params)
# chose total Sz= 4, not 3=6/2, i.e. not the sector with lowest energy!
# make sure below that we stay in that sector, if we're supposed to.
init_Sz_4 = ['up', 'down', 'up', 'up', 'up', 'down']
psi_Sz_4 = mps.MPS.from_product_state(M.lat.mps_sites(), init_Sz_4, bc=bc_MPS)
dmrg_pars = {
'verbose': 1,
'N_sweeps_check': 1,
'combine': True,
'max_sweeps': 5,
'diag_method': diag_method,
'mixer': True,
}
ED = ExactDiag(M)
ED.build_full_H_from_mpo()
ED.full_diagonalization()
if diag_method == "ED_all":
charge_sector = None # allow to change the sector
else:
charge_sector = [2] # don't allow to change the sector
E_ED, psi_ED = ED.groundstate(charge_sector=charge_sector)
DMRGEng = dmrg.__dict__.get(engine)
print("DMRGEng = ", DMRGEng)
print("setting diag_method = ", dmrg_pars['diag_method'])
eng = DMRGEng(psi_Sz_4.copy(), M, dmrg_pars)
E0, psi0 = eng.run()
print("E0 = {0:.15f}".format(E0))
assert abs(E_ED - E0) < tol
ov = npc.inner(psi_ED, ED.mps_to_full(psi0), 'range', do_conj=True)
assert abs(abs(ov) - 1) < tol
def test_tebd(bc_MPS, g=0.5):
L = 2 if bc_MPS == 'infinite' else 6
# xxz_pars = dict(L=L, Jxx=1., Jz=3., hz=0., bc_MPS=bc_MPS)
# M = XXZChain(xxz_pars)
# factor of 4 (2) for J (h) to change spin-1/2 to Pauli matrices
model_pars = dict(L=L, Jx=0., Jy=0., Jz=-4., hx=2. * g, bc_MPS=bc_MPS, conserve=None)
M = SpinChain(model_pars)
state = ([[1, -1.], [1, -1.]] * L)[:L] # pointing in (-x)-direction
psi = MPS.from_product_state(M.lat.mps_sites(), state, bc=bc_MPS)
tebd_param = {
'verbose': 2,
'dt': 0.01,
'order': 2,
'delta_tau_list': [0.1, 1.e-4, 1.e-8],
'max_error_E': 1.e-9,
'trunc_params': {
'chi_max': 50,
'trunc_cut': 1.e-13
}
}
engine = tebd.Engine(psi, M, tebd_param)
engine.run_GS()
print("norm_test", psi.norm_test())
if bc_MPS == 'finite':
psi.canonical_form()
ED = ExactDiag(M)
ED.build_full_H_from_mpo()
ED.full_diagonalization()
psi_ED = ED.groundstate()
Etebd = np.sum(M.bond_energies(psi))
Eexact = np.min(ED.E)
print("E_TEBD={Etebd:.14f} vs E_exact={Eex:.14f}".format(Etebd=Etebd, Eex=Eexact))
assert (abs((Etebd - Eexact) / Eexact) < 1.e-7)
ov = npc.inner(psi_ED, ED.mps_to_full(psi), do_conj=True)
print("compare with ED: overlap = ", abs(ov)**2)
assert (abs(abs(ov) - 1.) < 1.e-7)
# Test real time TEBD: should change on an eigenstate
Sold = np.average(psi.entanglement_entropy())
for i in range(3):
engine.run()
Enew = np.sum(M.bond_energies(psi))
Snew = np.average(psi.entanglement_entropy())
assert (abs(Enew - Etebd) < 1.e-8)
assert (abs(Sold - Snew) < 1.e-5) # somehow we need larger tolerance here....
if bc_MPS == 'infinite':
Etebd = np.average(M.bond_energies(psi))
Eexact = e0_tranverse_ising(g)
print("E_TEBD={Etebd:.14f} vs E_exact={Eex:.14f}".format(Etebd=Etebd, Eex=Eexact))
Sold = np.average(psi.entanglement_entropy())
for i in range(2):
engine.run()
Enew = np.average(M.bond_energies(psi))
Snew = np.average(psi.entanglement_entropy())
assert (abs(Etebd - Enew) < 1.e-7)
assert (abs(Sold - Snew) < 1.e-5) # somehow we need larger tolerance here....
def test_dmrg(bc_MPS, combine, mixer, n, g=1.2):
L = 2 if bc_MPS == 'infinite' else 8
model_params = dict(L=L, J=1., g=g, bc_MPS=bc_MPS, conserve=None, verbose=0)
M = TFIChain(model_params)
state = [0] * L # Ferromagnetic Ising
psi = mps.MPS.from_product_state(M.lat.mps_sites(), state, bc=bc_MPS)
dmrg_pars = {
'verbose': 5,
'combine': combine,
'mixer': mixer,
'chi_list': {
0: 10,
5: 30
},
'max_E_err': 1.e-12,
'max_S_err': 1.e-8,
'N_sweeps_check': 4,
'mixer_params': {
'disable_after': 15,
'amplitude': 1.e-5
},
'trunc_params': {
'svd_min': 1.e-10,
},
'max_N_for_ED': 20, # small enough that we test both diag_method=lanczos and ED_block!
'max_sweeps': 40,
'active_sites': n,
}
if not mixer:
del dmrg_pars['mixer_params'] # avoid warning of unused parameter
if bc_MPS == 'infinite':
# if mixer is not None:
# dmrg_pars['mixer_params']['amplitude'] = 1.e-12 # don't actually contribute...
dmrg_pars['start_env'] = 1
res = dmrg.run(psi, M, dmrg_pars)
if bc_MPS == 'finite':
ED = ExactDiag(M)
ED.build_full_H_from_mpo()
ED.full_diagonalization()
E_ED, psi_ED = ED.groundstate()
ov = npc.inner(psi_ED, ED.mps_to_full(psi), 'range', do_conj=True)
print("E_DMRG={Edmrg:.14f} vs E_exact={Eex:.14f}".format(Edmrg=res['E'], Eex=E_ED))
print("compare with ED: overlap = ", abs(ov)**2)
assert abs(abs(ov) - 1.) < 1.e-10 # unique groundstate: finite size gap!
var = M.H_MPO.variance(psi)
assert var < 1.e-10
else:
# compare exact solution for transverse field Ising model
Edmrg = res['E']
Eexact = e0_tranverse_ising(g)
print("E_DMRG={Edmrg:.12f} vs E_exact={Eex:.12f}".format(Edmrg=Edmrg, Eex=Eexact))
print("relative energy error: {err:.2e}".format(err=abs((Edmrg - Eexact) / Eexact)))
print("norm err:", psi.norm_test())
Edmrg2 = np.mean(psi.expectation_value(M.H_bond))
Edmrg3 = M.H_MPO.expectation_value(psi)
assert abs((Edmrg - Eexact) / Eexact) < 1.e-10
assert abs((Edmrg - Edmrg2) / Edmrg2) < max(1.e-10, np.max(psi.norm_test()))
assert abs((Edmrg - Edmrg3) / Edmrg3) < max(1.e-10, np.max(psi.norm_test()))
def check_dmrg(L=4, bc_MPS='finite', engine='EngineCombine', mixer=None, g=1.5):
model_params = dict(L=L, J=1., g=g, bc_MPS=bc_MPS, conserve=None, verbose=0)
M = TFIChain(model_params)
state = [0] * L # Ferromagnetic Ising
psi = mps.MPS.from_product_state(M.lat.mps_sites(), state, bc=bc_MPS)
dmrg_pars = {
'verbose': 5,
'engine': engine,
'mixer': mixer,
'chi_list': {
0: 10,
5: 30
},
'max_E_err': 1.e-12,
'max_S_err': 1.e-8,
'N_sweeps_check': 4,
'mixer_params': {
'disable_after': 6,
'amplitude': 1.e-5
},
'trunc_params': {
'svd_min': 1.e-10,
},
'lanczos_params': {
'reortho': True,
'N_cache': 20
},
'max_sweeps': 40,
}
if mixer is None:
del dmrg_pars['mixer_params'] # avoid warning of unused parameter
if bc_MPS == 'infinite':
if mixer is not None:
dmrg_pars['mixer_params']['amplitude'] = 1.e-12 # don't actually contribute...
dmrg_pars['start_env'] = 1
res = dmrg.run(psi, M, dmrg_pars)
if bc_MPS == 'finite':
ED = ExactDiag(M)
ED.build_full_H_from_mpo()
ED.full_diagonalization()
psi_ED = ED.groundstate()
ov = npc.inner(psi_ED, ED.mps_to_full(psi), do_conj=True)
print("E_DMRG={Edmrg:.14f} vs E_exact={Eex:.14f}".format(Edmrg=res['E'], Eex=np.min(ED.E)))
print("compare with ED: overlap = ", abs(ov)**2)
assert abs(abs(ov) - 1.) < 1.e-10 # unique groundstate: finite size gap!
else:
# compare exact solution for transverse field Ising model
Edmrg = res['E']
Eexact = e0_tranverse_ising(g)
print("E_DMRG={Edmrg:.12f} vs E_exact={Eex:.12f}".format(Edmrg=Edmrg, Eex=Eexact))
print("relative energy error: {err:.2e}".format(err=abs((Edmrg - Eexact) / Eexact)))
print("norm err:", psi.norm_test())
Edmrg2 = np.mean(psi.expectation_value(M.H_bond))
assert abs((Edmrg - Eexact) / Eexact) < 1.e-10
assert abs((Edmrg - Edmrg2) / Edmrg2) < max(1.e-10, np.max(psi.norm_test()))
import tenpy.linalg.np_conserved as npc
from tenpy.models.xxz_chain import XXZChain
from tenpy.networks.mps import MPS
from tenpy.algorithms.exact_diag import ExactDiag
from tenpy.algorithms.dmrg import run as run_DMRG
xxz_pars = dict(L=4, Jxx=1., Jz=1., hz=0.0, bc_MPS='finite')
M = XXZChain(xxz_pars)
ED = ExactDiag(M, [0])
ED.build_full_H_from_mpo()
# ED.build_full_H_from_bonds() # whatever you prefer
print("start diagonalization")
ED.full_diagonalization()
psi_ED = ED.groundstate()
print("psi_ED =", psi_ED)
print("start DMRG")
product_state = [0, 1] * (xxz_pars['L'] // 2) # this selects a charge sector!
psi_DMRG = MPS.from_product_state(M.lat.mps_sites(), product_state)
res = run_DMRG(psi_DMRG, M, {'verbose': 0})
# first way to compare ED with DMRG: convert MPS to ED vector
psi_DMRG_full = ED.mps_to_full(psi_DMRG)
print("psi_DMRG_full =", psi_DMRG_full)
ov = abs(npc.inner(psi_ED, psi_DMRG_full, do_conj=True))
print("|<psi_ED|psi_DMRG>| =", ov)
assert (abs(ov - 1.) < 1.e-13)
# second way: convert ED vector to MPS