def test_MPOGraph_term_conversion():
L = 4
g1 = mpo.MPOGraph([spin_half] * L, 'infinite')
g1.test_sanity()
for i in range(L):
g1.add(i, 'IdL', 'IdR', 'Sz', 0.5)
g1.add(i, 'IdL', ("left", i, 'Sp', 'Id'), 'Sp', 1.)
g1.add(i + 1, ("left", i, 'Sp', 'Id'), 'IdR', 'Sm', 1.5)
g1.add_missing_IdL_IdR()
terms = [[("Sz", i)] for i in range(L)]
terms += [[("Sp", i), ("Sm", i + 1)] for i in range(L)]
prefactors = [0.5] * L + [1.5] * L
term_list = TermList(terms, prefactors)
g2 = mpo.MPOGraph.from_term_list(term_list, [spin_half] * L, 'infinite')
g2.test_sanity()
assert g1.graph == g2.graph
terms[3:3] = [[("Sm", 2), ("Sp", 0), ("Sz", 1)]]
prefactors[3:3] = [3.]
term_list = TermList(terms, prefactors)
g3 = mpo.MPOGraph.from_term_list(term_list, [spin_half] * L, 'infinite')
g4 = mpo.MPOGraph([spin_half] * L, 'infinite')
g4.test_sanity()
for i in range(L):
g4.add(i, 'IdL', 'IdR', 'Sz', 0.5)
g4.add(i, 'IdL', ("left", i, 'Sp', 'Id'), 'Sp', 1.)
g4.add(i + 1, ("left", i, 'Sp', 'Id'), 'IdR', 'Sm', 1.5)
g4.add_missing_IdL_IdR()
g4.add(1, ("left", 0, 'Sp', 'Id'), ("right", 2, 'Sm', 'Id'), 'Sz', 3.)
g4.add(2, ("right", 2, 'Sm', 'Id'), 'IdR', 'Sm', 1.)
assert g4.graph == g3.graph
def test_expectation_value_term():
s = spin_half
psi1 = mps.MPS.from_singlets(s, 6, [(1, 3), (2, 5)], lonely=[0, 4], bc='finite')
ev = psi1.expectation_value_term([('Sz', 2), ('Sz', 3)])
assert abs(0. - ev) < 1.e-14
ev = psi1.expectation_value_term([('Sz', 1), ('Sz', 3)])
assert abs(-0.25 - ev) < 1.e-14
ev = psi1.expectation_value_term([('Sz', 3), ('Sz', 1), ('Sz', 4)])
assert abs(-0.25 * 0.5 - ev) < 1.e-14
fs = site.SpinHalfFermionSite()
# check fermionic signs
psi2 = mps.MPS.from_product_state([fs] * 4, ['empty', 'up', 'down', 'full'], bc="infinite")
ev = psi2.expectation_value_term([('Cu', 2), ('Nu', 1), ('Cdu', 2)])
assert 1. == ev
ev2 = psi2.expectation_value_term([('Cu', 2), ('Cd', 1), ('Cdd', 1), ('Cdu', 2)])
assert ev2 == ev
ev3 = psi2.expectation_value_term([('Cd', 1), ('Cu', 2), ('Cdd', 1), ('Cdu', 2)])
assert ev3 == -ev2
# over the infinite MPS boundary
ev = psi2.expectation_value_term([('Nu', 1), ('Nd', 4)]) # should be zero
assert abs(ev) == 0.
ev = psi2.expectation_value_term([('Nu', 1), ('Nd', 6)])
assert abs(ev) == 1.
# terms_sum
pref = np.random.random([5])
term_list = TermList(
[[('Nd', 0)], [('Nu', 1), ('Nd', 2)], [('Nd', 2),
('Nu', 5)], [('Nu Nd', 3)], [('Nu', 1),
('Nu', 5)]], pref)
desired = sum(pref[1:])
assert desired == sum(
[psi2.expectation_value_term(term) * strength for term, strength in term_list])
evsum, _ = psi2.expectation_value_terms_sum(term_list)
assert abs(evsum - desired) < 1.e-14
def test_TermList():
terms = [[('N', 3), ('N', 2), ('N', 3)], [('C', 0), ('N', 2), ('N', 4), ('Cd', 3), ('C', 2)],
[('C', 0), ('N', 2), ('N', 4), ('Cd', 3), ('Cd', 0), ('C', 2)]]
strength = [1., 2., 3.]
terms_copy = copy.deepcopy(terms)
terms_ordered = [[('N', 2), ('N N', 3)], [('C', 0), ('N C', 2), ('Cd', 3), ('N', 4)],
[('C Cd', 0), ('N C', 2), ('Cd', 3), ('N', 4)]]
tl = TermList(terms, strength)
print(tl)
tl.order_combine([dummy] * 7)
print(tl)
assert terms == terms_copy
assert tl.terms == terms_ordered
assert np.all(tl.strength == np.array(strength)) # no sites -> just permute
tl = TermList(terms, strength)
tl.order_combine([fermion] * 3) # should anti-commute
assert tl.terms == terms_ordered
assert np.all(tl.strength == np.array([1., -2., 3.]))
def calculate_expvals(self):
if self.dmrg_retval is None:
self.calculate_ground_state()
ESn = sum(
self.psi.expectation_value_multi_sites([oper, oper], i)
for i, oper in product(range(self.L - 1), ['Sx', 'Sy', 'Sz']))
relweight = 1
sstermlist = [ [(oper1,i),(oper2,i),(oper1,i+1),(oper2,i+1)]\
for oper1,oper2 in product(['Sx','Sy','Sz'],['Sx','Sy','Sz'])\
for i in range(self.L-1) ] #[(term,weight)], where term=[(operator,index),…]
sstermlistobject = TermList(sstermlist, np.ones(len(sstermlist)))
ESSn, _ = self.psi.expectation_value_terms_sum(
sstermlistobject
) #some intermediate calculations are also returned
ESz = sum(
self.psi.expectation_value_multi_sites(['Sz'], i)
for i in range(self.L))
return (ESn, ESSn, ESz)
def test_correlation_function():
s = spin_half
Pup = s.Id.copy()
Pup[s.state_labels['down'], s.state_labels['down']] = 0.
Pdown = s.Id.copy()
Pdown[s.state_labels['up'], s.state_labels['up']] = 0.
s.add_op('Pup', Pup, need_JW=False, hc='Pup')
s.add_op('Pdown', Pdown, need_JW=False, hc='Pdown')
psi1 = mps.MPS.from_singlets(s,
6, [(1, 3), (2, 5)],
lonely=[0, 4],
bc='finite')
corr1 = psi1.correlation_function('Sz', 'Sz')
corr1_exact = 0.25 * np.array([[ 1., 0., 0., 0., 1., 0.],
[ 0., 1., 0., -1., 0., 0.],
[ 0., 0., 1., 0., 0., -1.],
[ 0., -1., 0., 1., 0., 0.],
[ 1., 0., 0., 0., 1., 0.],
[ 0., 0., -1., 0., 0., 1.]]) # yapf: disable
npt.assert_almost_equal(corr1, corr1_exact)
corr1 = psi1.term_correlation_function_right([('Sz', 0)], [('Sz', 0)])
npt.assert_almost_equal(corr1, corr1_exact[0, 1:])
corr1 = psi1.term_correlation_function_right([('Sz', 0)], [('Sz', 1)])
npt.assert_almost_equal(corr1, corr1_exact[0, 1:])
corr1 = psi1.term_correlation_function_right([('Sz', 1)], [('Sz', 1)])
npt.assert_almost_equal(corr1, corr1_exact[1, 2:])
corr1 = psi1.term_correlation_function_right([('Sz', 1)], [('Sz', -1)])
npt.assert_almost_equal(corr1, corr1_exact[1, 2:-1])
corr1 = psi1.term_correlation_function_left([('Sz', 0)], [('Sz', 0)],
range(0, 5), 5)
npt.assert_almost_equal(corr1[::-1], corr1_exact[:-1, 5])
corr1 = psi1.term_correlation_function_left([('Sz', 1)], [('Sz', 1)],
range(0, 4), 4)
npt.assert_almost_equal(corr1[::-1], corr1_exact[1:-1, 5])
Sz = TermList([[('Pup', 0)], [('Pdown', 0)]],
[0.5, -0.5]) # complicated way to write Sz
corr1 = psi1.term_list_correlation_function_right(Sz, Sz)
# check term_list_correlation_function_right for terms with different qtotal
npt.assert_almost_equal(corr1, corr1_exact[0, 1:])
Sx = TermList([[('Sp', 0)], [('Sm', 0)]],
[0.5, +0.5]) # complicated way to write Sx_0
Sy = TermList([[('Sp', 1)], [('Sm', 1)]],
[-0.5j, +0.5j]) # complicated way to write Sy_1
corrxx = psi1.term_list_correlation_function_right(Sx, Sx)
npt.assert_almost_equal(corrxx, np.zeros((5, ))) # Sx_0 gives 0
corrxx = psi1.term_list_correlation_function_right(Sx, Sx, 1)
npt.assert_almost_equal(corrxx, 0.25 * np.array([0., -1., 0., 0.]))
corrxy = psi1.term_list_correlation_function_right(Sx, Sy, 1, range(1, 5))
npt.assert_almost_equal(corrxy, np.zeros((4, )))
# check fermionic signs
fs = site.SpinHalfFermionSite()
psi2 = mps.MPS.from_product_state([fs] * 4,
['empty', 'up', 'down', 'full'],
bc="infinite")
corr2 = psi2.correlation_function('Cdu', 'Cu')
corr2_exact = np.array([[ 0., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 0., 0.],
[ 0., 0., 0., 1.]]) # yapf: disable
npt.assert_almost_equal(corr2, corr2_exact)
psi3 = psi2.copy()
from tenpy.algorithms.tebd import RandomUnitaryEvolution
RandomUnitaryEvolution(psi3, {'N_steps': 4}).run()
corr3 = psi3.correlation_function('Cdu', 'Cu')
corr3_d = psi3.correlation_function('Cu', 'Cdu')
npt.assert_almost_equal(np.diag(corr3) + np.diag(corr3_d), 1.)
corr3 = corr3 - np.diag(np.diag(corr3)) # remove diagonal
corr3_d = corr3_d - np.diag(np.diag(corr3_d))
npt.assert_array_almost_equal(
corr3, -corr3_d.T) # check anti-commutation of operators
corr = psi3.term_correlation_function_right([('Cdu', 0)], [('Cu', 0)],
j_R=range(1, 4))
npt.assert_almost_equal(corr, corr3[0, 1:])
corr3_long = psi3.correlation_function('Cdu', 'Cu', [0],
range(4, 11 * 4, 4)).flatten()
corr3_long2 = psi3.term_correlation_function_right([('Cdu', 0)],
[('Cu', 0)])
npt.assert_array_almost_equal(corr3_long, corr3_long2)
term1 = TermList([[('Cdu', 0)]], [1.])
term2 = TermList([[('Cu', 0)], [('Ntot', -1)]],
[1., 2.]) # N shouldn't contribute!
corr3_long3 = psi3.term_list_correlation_function_right(term1, term2)
def test_MPO_conversion():
L = 8
sites = []
for i in range(L):
s = site.Site(spin_half.leg)
s.add_op("X_{i:d}".format(i=i), np.diag([2., 1.]))
s.add_op("Y_{i:d}".format(i=i), np.diag([1., 2.]))
sites.append(s)
terms = [
[("X_0", 0)],
[("X_0", 0), ("X_1", 1)],
[("X_0", 0), ("X_3", 3)],
[("X_4", 4), ("Y_5", 5), ("Y_7", 7)],
[("X_4", 4), ("Y_5", 5), ("X_7", 7)],
[("X_4", 4), ("Y_6", 6), ("Y_7", 7)],
]
prefactors = [0.25, 10., 11., 101., 102., 103.]
term_list = TermList(terms, prefactors)
g1 = mpo.MPOGraph.from_term_list(term_list,
sites,
bc='finite',
insert_all_id=False)
ct_add = MultiCouplingTerms(L)
ct_add.add_coupling_term(12., 4, 5, "X_4", "X_5")
ct_add.add_multi_coupling_term(0.5, [4, 5, 7], ["X_4", "Y_5", "X_7"], "Id")
ct_add.add_to_graph(g1)
H1 = g1.build_MPO()
grids = [
[['Id', 'X_0', [('X_0', 0.25)]] # site 0
],
[
['Id', None, None], # site 1
[None, 'Id', [('X_1', 10.0)]],
[None, None, 'Id']
],
[
['Id', None, None], # site 2
[None, [('Id', 11.0)], None],
[None, None, 'Id']
],
[
['Id', None], # site 3
[None, 'X_3'],
[None, 'Id']
],
[
['X_4', None], #site 4
[None, 'Id']
],
[
['Id', 'Y_5', [('X_5', 12.0)]], # site 5
[None, None, 'Id']
],
[
# site 6
[None, [('Y_6', 103.0)], None],
[[('Id', 102.5)], [('Id', 101.0)], None],
[None, None, 'Id']
],
[
['X_7'], # site 7
['Y_7'],
['Id']
]
]
H2 = mpo.MPO.from_grids(sites, grids, 'finite', [0] * 4 + [None] * 5,
[None] * 5 + [-1] * 4)
for w1, w2 in zip(H1._W, H2._W):
assert npc.norm(w1 - w2, np.inf) == 0.
pass