def test_mixed_indices(self):
expr = c_dag(0, "up") * c(1, "dn") \
+ a_dag("x") * n() + a("y") * n() + S_p() * S_m()
self.assertEqual(
str(expr),
"0.5 + 1*Sz() + 1*C+(0,up)C(1,dn) + 1*C+()C()A+(x) + 1*C+()C()A(y)"
)
def test_holstein_int(self):
g = np.array([1, 2, 3, 4], dtype=float)
indices_up = [("up", 0), ("up", 1), ("up", 2), ("up", 3)]
indices_dn = [("dn", 0), ("dn", 1), ("dn", 2), ("dn", 3)]
indices_boson = [('a', 0), ('b', 1), ('c', 2), ('d', 3)]
H1 = holstein_int(g)
self.assertIsInstance(H1, ExpressionR)
ref1 = sum(g[i] * (n(i, "up") + n(i, "dn")) * (a_dag(i) + a(i))
for i in range(4))
self.assertEqual(H1, ref1)
H2 = holstein_int(1j * g)
self.assertIsInstance(H2, ExpressionC)
ref2 = 1j * ref1
self.assertEqual(H2, ref2)
H3 = holstein_int(g,
indices_up=indices_up,
indices_dn=indices_dn,
indices_boson=indices_boson)
self.assertIsInstance(H3, ExpressionR)
ref3 = 1.0 * (n("up", 0) + n("dn", 0)) * (a_dag('a', 0) + a('a', 0))
ref3 += 2.0 * (n("up", 1) + n("dn", 1)) * (a_dag('b', 1) + a('b', 1))
ref3 += 3.0 * (n("up", 2) + n("dn", 2)) * (a_dag('c', 2) + a('c', 2))
ref3 += 4.0 * (n("up", 3) + n("dn", 3)) * (a_dag('d', 3) + a('d', 3))
self.assertEqual(H3, ref3)
def test_from_expression(self):
expr = 2.0 * S_p("i", 0, spin=3 / 2) * S_m("j", 0, spin=3 / 2) \
+ 5.0 * n("up", 0) * n("dn", 0)
hs1 = HilbertSpace(expr)
self.assertEqual(len(hs1), 4)
self.assertEqual(hs1.total_n_bits, 6)
self.assertEqual(hs1.dim, 64)
self.assertTrue(self.es_f_dn in hs1)
self.assertEqual(hs1.index(self.es_f_dn), 0)
self.assertEqual(hs1.bit_range(self.es_f_dn), (0, 0))
self.assertTrue(self.es_f_up in hs1)
self.assertEqual(hs1.index(self.es_f_up), 1)
self.assertEqual(hs1.bit_range(self.es_f_up), (1, 1))
self.assertTrue(self.es_s32_i in hs1)
self.assertEqual(hs1.index(self.es_s32_i), 2)
self.assertEqual(hs1.bit_range(self.es_s32_i), (2, 3))
self.assertTrue(self.es_s32_j in hs1)
self.assertEqual(hs1.index(self.es_s32_j), 3)
self.assertEqual(hs1.bit_range(self.es_s32_j), (4, 5))
# foreach()
count = 0
def counter(i):
nonlocal count
count += i
foreach(hs1, counter)
self.assertEqual(count, 2016)
expr += a_dag("x", 0) + a("y", 0)
hs2 = HilbertSpace(expr, bits_per_boson=4)
self.assertEqual(len(hs2), 6)
self.assertEqual(hs2.total_n_bits, 14)
self.assertEqual(hs2.dim, 16384)
self.assertTrue(self.es_f_dn in hs2)
self.assertEqual(hs2.index(self.es_f_dn), 0)
self.assertEqual(hs2.bit_range(self.es_f_dn), (0, 0))
self.assertTrue(self.es_f_up in hs2)
self.assertEqual(hs2.index(self.es_f_up), 1)
self.assertEqual(hs2.bit_range(self.es_f_up), (1, 1))
self.assertTrue(self.es_b_x in hs2)
self.assertEqual(hs2.index(self.es_b_x), 2)
self.assertEqual(hs2.bit_range(self.es_b_x), (2, 5))
self.assertTrue(self.es_b_y in hs2)
self.assertEqual(hs2.index(self.es_b_y), 3)
self.assertEqual(hs2.bit_range(self.es_b_y), (6, 9))
self.assertTrue(self.es_s32_i in hs2)
self.assertEqual(hs2.index(self.es_s32_i), 4)
self.assertEqual(hs2.bit_range(self.es_s32_i), (10, 11))
self.assertTrue(self.es_s32_j in hs2)
self.assertEqual(hs2.index(self.es_s32_j), 5)
self.assertEqual(hs2.bit_range(self.es_s32_j), (12, 13))
def test_find_connections(self):
expr = [ExpressionR(),
c_dag("up", 0) * c("dn", 1),
c_dag("up", 0) * c("dn", 1) + c_dag("dn", 0) * c("dn", 1),
c_dag("dn", 1) * c_dag("up", 1),
n("up", 2)
]
sp, melem = make_space_partition(self.Hop, self.hs, False)
op = LOperatorR(sum(expr[1:]), self.hs)
conns = sp.find_connections(op, self.hs)
conns_ref = set()
in_state = np.zeros((sp.dim,), dtype=float)
for i in range(sp.dim):
in_state[i] = 1.0
out_state = op * in_state
for f, a in enumerate(out_state):
if abs(a) > 1e-10:
conns_ref.add((sp[i], sp[f]))
in_state[i] = 0.0
self.assertEqual(conns, conns_ref)
for expr1, expr2 in product(expr, expr):
conns1 = sp.find_connections(LOperatorR(expr1, self.hs), self.hs)
conns2 = sp.find_connections(LOperatorR(expr2, self.hs), self.hs)
conns = sp.find_connections(LOperatorR(expr1 + expr2, self.hs),
self.hs)
self.assertEqual(conns, conns1.union(conns2))
def test_real_complex(self):
# Fermion
self.check_monomial(c_dag(1, "up"), 1, make_fermion(True, 1, "up"))
self.check_monomial(c(2, "dn"), 1, make_fermion(False, 2, "dn"))
self.check_monomial(n(1, "dn"), 1, make_fermion(True, 1, "dn"),
make_fermion(False, 1, "dn"))
# Boson
self.check_monomial(a_dag(0, "x"), 1, make_boson(True, 0, "x"))
self.check_monomial(a(0, "y"), 1, make_boson(False, 0, "y"))
# Spin 1/2
self.check_monomial(S_p(0, "x"), 1,
make_spin(SpinComponent.PLUS, 0, "x"))
self.check_monomial(S_m(0, "x"), 1,
make_spin(SpinComponent.MINUS, 0, "x"))
self.check_monomial(S_z(0, "x"), 1, make_spin(SpinComponent.Z, 0, "x"))
# Spin 1
self.check_monomial(S_p(0, "x", spin=1), 1,
make_spin(1.0, SpinComponent.PLUS, 0, "x"))
self.check_monomial(S_m(0, "x", spin=1), 1,
make_spin(1.0, SpinComponent.MINUS, 0, "x"))
self.check_monomial(S_z(0, "x", spin=1), 1,
make_spin(1.0, SpinComponent.Z, 0, "x"))
# Spin 3/2
self.check_monomial(S_p(0, "x", spin=3 / 2), 1,
make_spin(3 / 2, SpinComponent.PLUS, 0, "x"))
self.check_monomial(S_m(0, "x", spin=3 / 2), 1,
make_spin(3 / 2, SpinComponent.MINUS, 0, "x"))
self.check_monomial(S_z(0, "x", spin=3 / 2), 1,
make_spin(3 / 2, SpinComponent.Z, 0, "x"))
def test_loperator(self):
M = 5
hs = HilbertSpace([make_space_boson(2, 0)])
for i in range(M):
hs.add(make_space_fermion(i))
H = (n(0) + n(1) + n(2) + n(3) + n(4)) * (a_dag(0) + a(0))
for src_type, dst_type, lop_type in [(float, float, LOperatorR),
(float, complex, LOperatorR),
(complex, complex, LOperatorR),
(float, complex, LOperatorC),
(complex, complex, LOperatorC)]:
src_view_type = NFermionSectorViewR if (src_type == float) \
else NFermionSectorViewC
dst_view_type = NFermionSectorViewR if (dst_type == float) \
else NFermionSectorViewC
Hop = lop_type(H if lop_type == LOperatorR else make_complex(H),
hs)
for N in range(M + 1):
src = np.zeros(n_fermion_sector_size(hs, N), dtype=src_type)
view_src = src_view_type(src, hs, N)
dst = np.zeros(n_fermion_sector_size(hs, N), dtype=dst_type)
view_dst = dst_view_type(dst, hs, N)
# 1 boson, fermions in the first N modes
index_in_f = sum(2**i for i in range(N))
src[view_src.map_index(index_in_f + (2**M))] = 1
Hop(view_src, view_dst)
ref = np.zeros(n_fermion_sector_size(hs, N), dtype=dst_type)
# 0 bosons
ref[view_dst.map_index(index_in_f)] = N
# 2 bosons
ref[view_dst.map_index(index_in_f + (2 ** (M + 1)))] = \
N * np.sqrt(2)
assert_allclose(dst, ref)
def test_kondo_int(self):
J = np.array([1, 2, 3, 4], dtype=float)
indices_up = [("up", 0), ("up", 1), ("up", 2), ("up", 3)]
indices_dn = [("dn", 0), ("dn", 1), ("dn", 2), ("dn", 3)]
indices_spin = [('a', 0), ('b', 1), ('c', 2), ('d', 3)]
H1 = kondo_int(J)
self.assertIsInstance(H1, ExpressionR)
sp = [c_dag(i, "up") * c(i, "dn") for i in range(4)]
sm = [c_dag(i, "dn") * c(i, "up") for i in range(4)]
sz = [0.5 * (n(i, "up") - n(i, "dn")) for i in range(4)]
ref1 = 1.0 * (0.5 * (sp[0] * S_m(0) + sm[0] * S_p(0)) + sz[0] * S_z(0))
ref1 += 2.0 * (0.5 *
(sp[1] * S_m(1) + sm[1] * S_p(1)) + sz[1] * S_z(1))
ref1 += 3.0 * (0.5 *
(sp[2] * S_m(2) + sm[2] * S_p(2)) + sz[2] * S_z(2))
ref1 += 4.0 * (0.5 *
(sp[3] * S_m(3) + sm[3] * S_p(3)) + sz[3] * S_z(3))
self.assertEqual(H1, ref1)
H2 = kondo_int(1j * J)
self.assertIsInstance(H2, ExpressionC)
ref2 = 1j * ref1
self.assertEqual(H2, ref2)
H3 = kondo_int(J,
indices_up=indices_up,
indices_dn=indices_dn,
indices_spin=indices_spin)
self.assertIsInstance(H3, ExpressionR)
sp = [c_dag("up", i) * c("dn", i) for i in range(4)]
sm = [c_dag("dn", i) * c("up", i) for i in range(4)]
sz = [0.5 * (n("up", i) - n("dn", i)) for i in range(4)]
ref3 = 1.0 * (0.5 * (sp[0] * S_m('a', 0) + sm[0] * S_p('a', 0)) +
sz[0] * S_z('a', 0))
ref3 += 2.0 * (0.5 * (sp[1] * S_m('b', 1) + sm[1] * S_p('b', 1)) +
sz[1] * S_z('b', 1))
ref3 += 3.0 * (0.5 * (sp[2] * S_m('c', 2) + sm[2] * S_p('c', 2)) +
sz[2] * S_z('c', 2))
ref3 += 4.0 * (0.5 * (sp[3] * S_m('d', 3) + sm[3] * S_p('d', 3)) +
sz[3] * S_z('d', 3))
self.assertEqual(H3, ref3)
H4 = kondo_int(J, spin=1)
self.assertIsInstance(H4, ExpressionR)
sp = [c_dag(i, "up") * c(i, "dn") for i in range(4)]
sm = [c_dag(i, "dn") * c(i, "up") for i in range(4)]
sz = [0.5 * (n(i, "up") - n(i, "dn")) for i in range(4)]
ref4 = 1.0 * (0.5 *
(sp[0] * S1_m(0) + sm[0] * S1_p(0)) + sz[0] * S1_z(0))
ref4 += 2.0 * (0.5 *
(sp[1] * S1_m(1) + sm[1] * S1_p(1)) + sz[1] * S1_z(1))
ref4 += 3.0 * (0.5 *
(sp[2] * S1_m(2) + sm[2] * S1_p(2)) + sz[2] * S1_z(2))
ref4 += 4.0 * (0.5 *
(sp[3] * S1_m(3) + sm[3] * S1_p(3)) + sz[3] * S1_z(3))
self.assertEqual(H4, ref4)
def test_t_j_int(self):
J = np.array([[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]],
dtype=float)
indices_up = [("up", 0), ("up", 1), ("up", 2), ("up", 3)]
indices_dn = [("dn", 0), ("dn", 1), ("dn", 2), ("dn", 3)]
H1 = t_j_int(J)
self.assertIsInstance(H1, ExpressionR)
sp = [c_dag(i, "up") * c(i, "dn") for i in range(4)]
sm = [c_dag(i, "dn") * c(i, "up") for i in range(4)]
sz = [0.5 * (n(i, "up") - n(i, "dn")) for i in range(4)]
ni = [n(i, "up") + n(i, "dn") for i in range(4)]
ref1 = 0.5 * (sp[0] * sm[1] + sm[0] * sp[1]) + sz[0] * sz[1]
ref1 += -0.25 * ni[0] * ni[1]
ref1 += 2.0 * (0.5 * (sp[1] * sm[2] + sm[1] * sp[2]) + sz[1] * sz[2])
ref1 += -0.5 * ni[1] * ni[2]
ref1 += 3.0 * (0.5 * (sp[2] * sm[3] + sm[2] * sp[3]) + sz[2] * sz[3])
ref1 += -0.75 * ni[2] * ni[3]
self.assertEqual(H1, ref1)
H2 = t_j_int(1j * J)
self.assertIsInstance(H2, ExpressionC)
ref2 = 1j * ref1
self.assertEqual(H2, ref2)
H3 = t_j_int(J, indices_up=indices_up, indices_dn=indices_dn)
self.assertIsInstance(H3, ExpressionR)
sp = [c_dag("up", i) * c("dn", i) for i in range(4)]
sm = [c_dag("dn", i) * c("up", i) for i in range(4)]
sz = [0.5 * (n("up", i) - n("dn", i)) for i in range(4)]
ni = [n("up", i) + n("dn", i) for i in range(4)]
ref3 = 0.5 * (sp[0] * sm[1] + sm[0] * sp[1]) + sz[0] * sz[1]
ref3 += -0.25 * ni[0] * ni[1]
ref3 += 2.0 * (0.5 * (sp[1] * sm[2] + sm[1] * sp[2]) + sz[1] * sz[2])
ref3 += -0.5 * ni[1] * ni[2]
ref3 += 3.0 * (0.5 * (sp[2] * sm[3] + sm[2] * sp[3]) + sz[2] * sz[3])
ref3 += -0.75 * ni[2] * ni[3]
self.assertEqual(H3, ref3)
def test_loperator(self):
hs = HilbertSpace([make_space_boson(2, 0)])
for i in range(self.M_total):
hs.add(make_space_fermion(i))
sector_a_modes = [1, 2, 6, 7]
sector_b_modes = [3, 4, 8, 9]
Ha = (n(1) + n(2) + n(6) + n(7)) * (a_dag(0) + a(0))
Hb = (n(3) + n(4) + n(8) + n(9)) * (a_dag(0) + a(0))
for src_type, dst_type, lop_type in [(float, float, LOperatorR),
(float, complex, LOperatorR),
(complex, complex, LOperatorR),
(float, complex, LOperatorC),
(complex, complex, LOperatorC)]:
src_view_type = NFermionMultiSectorViewR if (src_type == float) \
else NFermionMultiSectorViewC
dst_view_type = NFermionMultiSectorViewR if (dst_type == float) \
else NFermionMultiSectorViewC
lop_is_real = lop_type == LOperatorR
Hopa = lop_type(Ha if lop_is_real else make_complex(Ha), hs)
Hopb = lop_type(Hb if lop_is_real else make_complex(Hb), hs)
for N1, N2 in product(range(self.Na_max + 1),
range(self.Nb_max + 1)):
sectors = [self.sda(N1), self.sdb(N2)]
src = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=src_type)
view_src = src_view_type(src, hs, sectors)
dst = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=dst_type)
view_dst = dst_view_type(dst, hs, sectors)
# Input:
# First N1 modes of sector A are occupied
# First N2 modes of sector B are occupied
# 1 boson
index_in_f = sum(2**sector_a_modes[n1] for n1 in range(N1))
index_in_f += sum(2**sector_b_modes[n2] for n2 in range(N2))
src[view_src.map_index(index_in_f + (2**self.M_total))] = 1
Hopa(view_src, view_dst)
ref = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=dst_type)
# 0 bosons
ref[view_dst.map_index(index_in_f)] = N1
# 2 bosons
ref[view_dst.map_index(index_in_f + (2 ** (self.M_total + 1)))]\
= N1 * np.sqrt(2)
assert_allclose(dst, ref)
Hopb(view_src, view_dst)
ref = np.zeros(n_fermion_multisector_size(hs, sectors),
dtype=dst_type)
# 0 bosons
ref[view_dst.map_index(index_in_f)] = N2
# 2 bosons
ref[view_dst.map_index(index_in_f + (2 ** (self.M_total + 1)))]\
= N2 * np.sqrt(2)
assert_allclose(dst, ref)
indices_boson=indices_phonon)
# Complete Holstein Hamiltonian.
H_H = H_e + H_ph + H_e_ph
# Print H_H. There will be quite a lot of terms for the 100-site lattice!
print("H_H =", H_H)
# Check hermiticity of H_H.
print(r"H_H - H_H^\dagger =", H_H - conj(H_H))
# Check that H_H commutes with the total number of electrons N_e.
N_e = ExpressionR()
for spin in ("up", "down"):
for x, y in product(range(N), range(N)):
N_e += n(x, y, spin)
print("[H_H, N_e] =", H_H * N_e - N_e * H_H)
#
# Iteration interface
#
# Iterate over monomial-coefficient pairs in polynomial expression H_H
for monomial, coeff in H_H:
print("Coefficient:", coeff)
# Iterate over algebra generators (creation/annihilation operators)
# in the monomial
for generator in monomial:
# Detect what algebra this generator belongs to
if generator.algebra_id == FERMION:
def test_slater_int(self):
spins = ("up", "dn")
F0 = 400
F2 = 100
U = F0 + 4 * F2 / 25
J = 3 * F2 / 25
# L = 0
H1 = slater_int(np.array([F0]))
self.assertIsInstance(H1, ExpressionR)
ref1 = F0 * n(0, "up") * n(0, "dn")
self.assertEqual(H1, ref1)
# L = 1
orbs = (-1, 0, 1)
H2 = slater_int(np.array([F0, F2]))
self.assertIsInstance(H2, ExpressionR)
N = sum(n(m, "up") + n(m, "dn") for m in orbs)
sp = sum(c_dag(m, "up") * c(m, "dn") for m in orbs)
sz = sum(0.5 * (n(m, "up") - n(m, "dn")) for m in orbs)
s2 = 0.5 * (sp * conj(sp) + conj(sp) * sp) + sz * sz
lp = np.sqrt(2) * sum(
c_dag(1, s) * c(0, s) + c_dag(0, s) * c(-1, s) for s in spins)
lz = sum(n(1, s) - n(-1, s) for s in spins)
l2 = 0.5 * (lp * conj(lp) + conj(lp) * lp) + lz * lz
ref2 = (4 * J - U / 2) * N + 0.5 * (U - 3 * J) * N * N
ref2 += -J * (2 * s2 + 0.5 * l2)
self.assertEqual(H2 - ref2, ExpressionR())
H3 = slater_int(1j * np.array([F0, F2]))
self.assertIsInstance(H3, ExpressionC)
ref3 = 1j * ref2
self.assertEqual(H3 - ref3, ExpressionC())
H4 = slater_int(np.array([F0, F2]),
indices_up=[("up", -1), ("up", 0), ("up", 1)],
indices_dn=[("dn", -1), ("dn", 0), ("dn", 1)])
self.assertIsInstance(H4, ExpressionR)
N = sum(n("up", m) + n("dn", m) for m in orbs)
sp = sum(c_dag("up", m) * c("dn", m) for m in orbs)
sz = sum(0.5 * (n("up", m) - n("dn", m)) for m in orbs)
s2 = 0.5 * (sp * conj(sp) + conj(sp) * sp) + sz * sz
lp = np.sqrt(2) * sum(
c_dag(s, 1) * c(s, 0) + c_dag(s, 0) * c(s, -1) for s in spins)
lz = sum(n(s, 1) - n(s, -1) for s in spins)
l2 = 0.5 * (lp * conj(lp) + conj(lp) * lp) + lz * lz
ref4 = (4 * J - U / 2) * N + 0.5 * (U - 3 * J) * N * N
ref4 += -J * (2 * s2 + 0.5 * l2)
self.assertEqual(H4 - ref4, ExpressionR())
def test_kanamori_int(self):
U = 4.0
J = 0.5
Up = 2.0
Jx = 0.5
Jp = 0.25
indices_up = [("up", 0), ("up", 1)]
indices_dn = [("dn", 0), ("dn", 1)]
self.assertIsInstance(kanamori_int(2, U, J), ExpressionR)
self.assertIsInstance(kanamori_int(2, 1j * U, J), ExpressionC)
self.assertIsInstance(kanamori_int(2, 1j * U, 1j * J), ExpressionC)
self.assertIsInstance(kanamori_int(2, U, J, Up), ExpressionR)
self.assertIsInstance(kanamori_int(2, U, J, 1j * Up), ExpressionC)
self.assertIsInstance(kanamori_int(2, U, J, Up, Jx, Jp), ExpressionR)
self.assertIsInstance(kanamori_int(2, U, J, Up, 1j * Jx, Jp),
ExpressionC)
self.assertIsInstance(kanamori_int(2, U, J, Up, Jx, 1j * Jp),
ExpressionC)
H1 = kanamori_int(2, U, J, Up, Jx, Jp)
ref1 = 4.0 * (n(0, "up") * n(0, "dn") + n(1, "up") * n(1, "dn"))
ref1 += 2.0 * (n(0, "up") * n(1, "dn") + n(1, "up") * n(0, "dn"))
ref1 += 1.5 * (n(0, "up") * n(1, "up") + n(1, "dn") * n(0, "dn"))
ref1 += 0.5 * (c_dag(0, "up") * c_dag(1, "dn") * c(0, "dn") *
c(1, "up"))
ref1 += 0.5 * (c_dag(1, "up") * c_dag(0, "dn") * c(1, "dn") *
c(0, "up"))
ref1 += 0.25 * (c_dag(0, "up") * c_dag(0, "dn") * c(1, "dn") *
c(1, "up"))
ref1 += 0.25 * (c_dag(1, "up") * c_dag(1, "dn") * c(0, "dn") *
c(0, "up"))
self.assertEqual(H1, ref1)
H2 = kanamori_int(2,
U,
J,
Up,
Jx,
Jp,
indices_up=indices_up,
indices_dn=indices_dn)
ref2 = 4.0 * (n("up", 0) * n("dn", 0) + n("up", 1) * n("dn", 1))
ref2 += 2.0 * (n("up", 0) * n("dn", 1) + n("up", 1) * n("dn", 0))
ref2 += 1.5 * (n("up", 0) * n("up", 1) + n("dn", 1) * n("dn", 0))
ref2 += 0.5 * (c_dag("up", 0) * c_dag("dn", 1) * c("dn", 0) *
c("up", 1))
ref2 += 0.5 * (c_dag("up", 1) * c_dag("dn", 0) * c("dn", 1) *
c("up", 0))
ref2 += 0.25 * (c_dag("up", 0) * c_dag("dn", 0) * c("dn", 1) *
c("up", 1))
ref2 += 0.25 * (c_dag("up", 1) * c_dag("dn", 1) * c("dn", 0) *
c("up", 0))
self.assertEqual(H2, ref2)
self.assertEqual(kanamori_int(2, U, J),
kanamori_int(2, U, J, U - 2 * J, J, J))
self.assertEqual(kanamori_int(2, U, J, Up),
kanamori_int(2, U, J, Up, J, J))
def test_extended_hubbard_int(self):
V = np.array([[0, 1, 0, 0], [0, 0, 2, 0], [0, 0, 0, 3], [0, 0, 0, 0]],
dtype=float)
indices_up = [("up", 0), ("up", 1), ("up", 2), ("up", 3)]
indices_dn = [("dn", 0), ("dn", 1), ("dn", 2), ("dn", 3)]
H1 = extended_hubbard_int(V)
self.assertIsInstance(H1, ExpressionR)
ref1 = 0.5 * (n(0, "up") + n(0, "dn")) * (n(1, "up") + n(1, "dn")) \
+ 1.0 * (n(1, "up") + n(1, "dn")) * (n(2, "up") + n(2, "dn")) \
+ 1.5 * (n(2, "up") + n(2, "dn")) * (n(3, "up") + n(3, "dn"))
self.assertEqual(H1, ref1)
H2 = extended_hubbard_int(1j * V)
self.assertIsInstance(H2, ExpressionC)
ref2 = 1j * ref1
self.assertEqual(H2, ref2)
H3 = extended_hubbard_int(V,
indices_up=indices_up,
indices_dn=indices_dn)
self.assertIsInstance(H3, ExpressionR)
ref3 = 0.5 * (n("up", 0) + n("dn", 0)) * (n("up", 1) + n("dn", 1)) \
+ 1.0 * (n("up", 1) + n("dn", 1)) * (n("up", 2) + n("dn", 2)) \
+ 1.5 * (n("up", 2) + n("dn", 2)) * (n("up", 3) + n("dn", 3))
self.assertEqual(H3, ref3)
def test_hubbard_int(self):
U = np.array([1, 2, 3, 4], dtype=float)
indices_up = [("up", 0), ("up", 1), ("up", 2), ("up", 3)]
indices_dn = [("dn", 0), ("dn", 1), ("dn", 2), ("dn", 3)]
H1 = hubbard_int(U)
self.assertIsInstance(H1, ExpressionR)
ref1 = n(0, "up") * n(0, "dn") + 2.0 * n(1, "up") * n(1, "dn") \
+ 3.0 * n(2, "up") * n(2, "dn") + 4.0 * n(3, "up") * n(3, "dn")
self.assertEqual(H1, ref1)
H2 = hubbard_int(1j * U)
self.assertIsInstance(H2, ExpressionC)
ref2 = 1j * ref1
self.assertEqual(H2, ref2)
H3 = hubbard_int(U, indices_up=indices_up, indices_dn=indices_dn)
self.assertIsInstance(H3, ExpressionR)
ref3 = n("up", 0) * n("dn", 0) + 2.0 * n("up", 1) * n("dn", 1) \
+ 3.0 * n("up", 2) * n("dn", 2) + 4.0 * n("up", 3) * n("dn", 3)
self.assertEqual(H3, ref3)
def test_zeeman(self):
b1 = np.array([1, 2, 3, 0], dtype=float)
b2 = np.array([[1, 0, 0], [0, 2, 0], [0, 0, 3], [0, 0, 0]],
dtype=float)
indices_up = [("up", 0), ("up", 1), ("up", 2), ("up", 3)]
indices_dn = [("dn", 0), ("dn", 1), ("dn", 2), ("dn", 3)]
H1 = zeeman(b1)
self.assertIsInstance(H1, ExpressionR)
ref1 = n(0, "up") - n(0, "dn") + 2.0 * (n(1, "up") - n(1, "dn")) \
+ 3.0 * (n(2, "up") - n(2, "dn"))
self.assertEqual(H1, ref1)
H2 = zeeman(1j * b1)
self.assertIsInstance(H2, ExpressionC)
ref2 = 1j * ref1
self.assertEqual(H2, ref2)
H3 = zeeman(b1, indices_up=indices_up, indices_dn=indices_dn)
self.assertIsInstance(H3, ExpressionR)
ref3 = n("up", 0) - n("dn", 0) + 2.0 * (n("up", 1) - n("dn", 1)) \
+ 3.0 * (n("up", 2) - n("dn", 2))
self.assertEqual(H3, ref3)
H4 = zeeman(b2)
self.assertIsInstance(H4, ExpressionC)
ref4 = (c_dag(0, "up") * c(0, "dn") + c_dag(0, "dn") * c(0, "up")) \
+ 2.0j * (c_dag(1, "dn") * c(1, "up")
- c_dag(1, "up") * c(1, "dn")) \
+ 3.0 * (n(2, "up") - n(2, "dn"))
self.assertEqual(H4, ref4)
H5 = zeeman(1j * b2)
self.assertIsInstance(H5, ExpressionC)
ref5 = 1j * ref4
self.assertEqual(H5, ref5)
H6 = zeeman(b2, indices_up=indices_up, indices_dn=indices_dn)
self.assertIsInstance(H6, ExpressionC)
ref6 = (c_dag("up", 0) * c("dn", 0) + c_dag("dn", 0) * c("up", 0)) \
+ 2.0j * (c_dag("dn", 1) * c("up", 1)
- c_dag("up", 1) * c("dn", 1)) \
+ 3.0 * (n("up", 2) - n("dn", 2))
self.assertEqual(H6, ref6)