def test_compositions(self):
mapper = BasisMapper([], self.hs, 0)
self.assertEqual(len(mapper), 1)
self.assertEqual(mapper.map[0], 0)
O_list = [LOperatorR(c_dag("dn", 1), self.hs),
LOperatorR(c_dag("dn", 2), self.hs),
LOperatorR(c_dag("up", 1), self.hs),
LOperatorR(c_dag("up", 2), self.hs)]
mapper_N0 = BasisMapper(O_list, self.hs, 0)
self.assertEqual(len(mapper_N0), 1)
self.assertEqual(mapper_N0.map[0], 0)
mapper_N2 = BasisMapper(O_list, self.hs, 2)
self.assert_equal_dicts_up_to_value_permutation(mapper_N2.map,
self.mapping)
O_list_complex = [LOperatorC(1j * c_dag("dn", 1), self.hs),
LOperatorC(1j * c_dag("dn", 2), self.hs),
LOperatorC(1j * c_dag("up", 1), self.hs),
LOperatorC(1j * c_dag("up", 2), self.hs)]
mapper_N2 = BasisMapper(O_list_complex, self.hs, 2)
self.assert_equal_dicts_up_to_value_permutation(mapper_N2.map,
self.mapping)
def test_basis_state_indices(self):
indices = [("dn", 0), ("dn", 1), ("up", 0), ("up", 1)]
hs = HilbertSpace([make_space_fermion(*ind) for ind in indices])
# Basis of the N=2 sector
basis_state_indices = [3, 5, 6, 9, 10, 12]
H1 = 1.0 * (c_dag("up", 0) * c("up", 1) + c_dag("up", 1) * c("up", 0))
H1 += 2.0 * (c_dag("dn", 0) * c("dn", 1) + c_dag("dn", 1) * c("dn", 0))
H1op = LOperatorR(H1, hs)
ref1 = 1.0 * (self.c_dag_mat(hs, "up", 0) @ self.c_mat(hs, "up", 1) +
self.c_dag_mat(hs, "up", 1) @ self.c_mat(hs, "up", 0))
ref1 += 2.0 * (self.c_dag_mat(hs, "dn", 0) @ self.c_mat(hs, "dn", 1) +
self.c_dag_mat(hs, "dn", 1) @ self.c_mat(hs, "dn", 0))
ref1 = ref1[basis_state_indices, :][:, basis_state_indices]
assert_equal(make_matrix(H1op, basis_state_indices), ref1)
H2 = 1.0j * (c_dag("up", 0) * c("up", 1) + c_dag("up", 1) * c("up", 0))
H2 += 2.0 * (c_dag("dn", 0) * c("dn", 1) + c_dag("dn", 1) * c("dn", 0))
H2op = LOperatorC(H2, hs)
ref2 = 1.0j * (self.c_dag_mat(hs, "up", 0) @ self.c_mat(hs, "up", 1) +
self.c_dag_mat(hs, "up", 1) @ self.c_mat(hs, "up", 0))
ref2 += 2.0 * (self.c_dag_mat(hs, "dn", 0) @ self.c_mat(hs, "dn", 1) +
self.c_dag_mat(hs, "dn", 1) @ self.c_mat(hs, "dn", 0))
ref2 = ref2[basis_state_indices, :][:, basis_state_indices]
assert_equal(make_matrix(H2op, basis_state_indices), ref2)
def test_HilbertSpace(self):
indices = [("dn", 0), ("dn", 1), ("up", 0), ("up", 1)]
hs = HilbertSpace([make_space_fermion(*ind) for ind in indices])
for ind in indices:
c_op = LOperatorR(c(*ind), hs)
assert_equal(make_matrix(c_op, hs), self.c_mat(hs, *ind))
c_dag_op = LOperatorR(c_dag(*ind), hs)
assert_equal(make_matrix(c_dag_op, hs), self.c_dag_mat(hs, *ind))
H1 = 1.0 * (c_dag("up", 0) * c("up", 1) + c_dag("up", 1) * c("up", 0))
H1 += 2.0 * (c_dag("dn", 0) * c("dn", 1) + c_dag("dn", 1) * c("dn", 0))
H1op = LOperatorR(H1, hs)
ref1 = 1.0 * (self.c_dag_mat(hs, "up", 0) @ self.c_mat(hs, "up", 1) +
self.c_dag_mat(hs, "up", 1) @ self.c_mat(hs, "up", 0))
ref1 += 2.0 * (self.c_dag_mat(hs, "dn", 0) @ self.c_mat(hs, "dn", 1) +
self.c_dag_mat(hs, "dn", 1) @ self.c_mat(hs, "dn", 0))
assert_equal(make_matrix(H1op, hs), ref1)
H2 = 1.0j * (c_dag("up", 0) * c("up", 1) + c_dag("up", 1) * c("up", 0))
H2 += 2.0 * (c_dag("dn", 0) * c("dn", 1) + c_dag("dn", 1) * c("dn", 0))
H2op = LOperatorC(H2, hs)
ref2 = 1.0j * (self.c_dag_mat(hs, "up", 0) @ self.c_mat(hs, "up", 1) +
self.c_dag_mat(hs, "up", 1) @ self.c_mat(hs, "up", 0))
ref2 += 2.0 * (self.c_dag_mat(hs, "dn", 0) @ self.c_mat(hs, "dn", 1) +
self.c_dag_mat(hs, "dn", 1) @ self.c_mat(hs, "dn", 0))
assert_equal(make_matrix(H2op, hs), ref2)
def test_overload_selection(self):
expr = 6 * c_dag("dn") - 6 * c("up")
hs = HilbertSpace(expr)
lop = LOperatorR(expr, hs)
src_int = np.array([1, 1, 1, 1], dtype=int)
src_real = np.array([1, 1, 1, 1], dtype=float)
src_complex = np.array([1, 1, 1, 1], dtype=complex)
ref_real = np.array([-6, 12, 0, 6], dtype=float)
ref_complex = np.array([-6, 12, 0, 6], dtype=complex)
self.assertEqual((lop * src_int).dtype, np.float64)
self.assertEqual((lop * src_real).dtype, np.float64)
self.assertEqual((lop * src_complex).dtype, np.complex128)
dst_int = np.zeros(4, dtype=int)
dst_real = np.zeros(4, dtype=float)
dst_complex = np.zeros(4, dtype=complex)
self.assertRaises(TypeError, lop, src_int, dst_int)
self.assertRaises(TypeError, lop, src_real, dst_int)
self.assertRaises(TypeError, lop, src_complex, dst_int)
self.assertRaises(TypeError, lop, src_complex, dst_real)
lop(src_int, dst_real)
assert_equal(dst_real, ref_real)
lop(src_int, dst_complex)
assert_equal(dst_complex, ref_complex)
lop(src_real, dst_real)
assert_equal(dst_real, ref_real)
lop(src_real, dst_complex)
assert_equal(dst_complex, ref_complex)
lop(src_complex, dst_complex)
assert_equal(dst_complex, ref_complex)
expr = 6j * c_dag("dn") - 6j * c("up")
hs = HilbertSpace(expr)
lop = LOperatorC(expr, hs)
self.assertEqual((lop * src_int).dtype, np.complex128)
self.assertEqual((lop * src_real).dtype, np.complex128)
self.assertEqual((lop * src_complex).dtype, np.complex128)
ref_complex = np.array([-6j, 12j, 0, 6j], dtype=complex)
self.assertRaises(TypeError, lop, src_int, dst_int)
self.assertRaises(TypeError, lop, src_real, dst_int)
self.assertRaises(TypeError, lop, src_complex, dst_int)
self.assertRaises(TypeError, lop, src_int, dst_real)
self.assertRaises(TypeError, lop, src_real, dst_real)
self.assertRaises(TypeError, lop, src_complex, dst_real)
lop(src_int, dst_complex)
assert_equal(dst_complex, ref_complex)
lop(src_real, dst_complex)
assert_equal(dst_complex, ref_complex)
lop(src_complex, dst_complex)
assert_equal(dst_complex, ref_complex)
def test_LOperatorC(self):
expr1 = make_complex(3 * c_dag("dn"))
expr2 = make_complex(3 * c("up"))
expr = 2j * expr1 - 2j * expr2
hs = HilbertSpace(expr)
lop1 = LOperatorC(expr1, hs)
lop2 = LOperatorC(expr2, hs)
lop = LOperatorC(expr, hs)
src = np.array([1, 1, 1, 1])
dst = np.zeros((4, ), dtype=complex)
assert_equal(lop1 * src, np.array([0, 3, 0, 3], dtype=complex))
lop1(src, dst)
assert_equal(dst, np.array([0, 3, 0, 3], dtype=complex))
assert_equal(lop2 * src, np.array([3, -3, 0, 0], dtype=complex))
lop2(src, dst)
assert_equal(dst, np.array([3, -3, 0, 0], dtype=complex))
assert_equal(lop * src, np.array([-6j, 12j, 0, 6j]))
lop(src, dst)
assert_equal(dst, np.array([-6j, 12j, 0, 6j]))
src_complex = 1j * np.array([1, 1, 1, 1])
assert_equal(lop * src_complex, np.array([6, -12, 0, -6]))
lop(src_complex, dst)
assert_equal(dst, np.array([6, -12, 0, -6]))
with self.assertRaisesRegex(
RuntimeError, "^State vector must be a 1-dimensional array$"):
lop * np.zeros((3, 3, 3))
with self.assertRaisesRegex(
RuntimeError,
"^Source state vector must be a 1-dimensional array$"):
lop(np.zeros((3, 3, 3)), np.zeros((5, ), dtype=complex))
with self.assertRaisesRegex(
RuntimeError,
"^Destination state vector must be a 1-dimensional array$"):
lop(np.zeros((5, )), np.zeros((3, 3, 3), dtype=complex))
def test_left_right_basis_state_indices(self):
indices = [("dn", 0), ("dn", 1), ("up", 0), ("up", 1)]
hs = HilbertSpace([make_space_fermion(*ind) for ind in indices])
# Basis of the N=1 sector
N1_basis_state_indices = [1, 2, 4, 8]
# Basis of the N=2 sector
N2_basis_state_indices = [3, 5, 6, 9, 10, 12]
# Basis of the N=3 sector
N3_basis_state_indices = [7, 11, 13, 14]
for ind1, ind2 in product(indices, indices):
op1 = LOperatorR(c(*ind1) * c(*ind2), hs)
ref1 = self.c_mat(hs, *ind1) @ self.c_mat(hs, *ind2)
ref1 = ref1[N1_basis_state_indices, :][:, N3_basis_state_indices]
assert_equal(
make_matrix(op1, N1_basis_state_indices,
N3_basis_state_indices), ref1)
op2 = LOperatorC(1j * c(*ind1) * c(*ind2), hs)
ref2 = 1j * self.c_mat(hs, *ind1) @ self.c_mat(hs, *ind2)
ref2 = ref2[N1_basis_state_indices, :][:, N3_basis_state_indices]
assert_equal(
make_matrix(op2, N1_basis_state_indices,
N3_basis_state_indices), ref2)
for ind in indices:
op1 = LOperatorR(c(*ind), hs)
ref1 = self.c_mat(hs, *ind)
ref1 = ref1[N2_basis_state_indices, :][:, N3_basis_state_indices]
assert_equal(
make_matrix(op1, N2_basis_state_indices,
N3_basis_state_indices), ref1)
op2 = LOperatorC(1j * c(*ind), hs)
ref2 = 1j * self.c_mat(hs, *ind)
ref2 = ref2[N2_basis_state_indices, :][:, N3_basis_state_indices]
assert_equal(
make_matrix(op2, N2_basis_state_indices,
N3_basis_state_indices), ref2)
def test_O_vac(self):
P = c_dag("dn", 1) * c_dag("dn", 2) + \
c_dag("dn", 1) * c_dag("up", 1) + \
c_dag("dn", 2) * c_dag("up", 1) + \
c_dag("dn", 1) * c_dag("up", 2) + \
c_dag("dn", 2) * c_dag("up", 2) + \
c_dag("up", 1) * c_dag("up", 2)
mapper = BasisMapper(LOperatorR(P, self.hs), self.hs)
self.assertEqual(len(mapper), 6)
self.assert_equal_dicts_up_to_value_permutation(mapper.map,
self.mapping)
mapper = BasisMapper(LOperatorC(1j * P, self.hs), self.hs)
self.assertEqual(len(mapper), 6)
self.assert_equal_dicts_up_to_value_permutation(mapper.map,
self.mapping)
def test_strided_arrays(self):
expr = 6 * c_dag("dn") - 6 * c("up")
hs = HilbertSpace(expr)
lop = LOperatorR(expr, hs)
src_real = 999 * np.ones((10, ), dtype=float)
src_real[3:10:2] = 1
src_complex = np.array(src_real, dtype=complex)
assert_equal(lop * src_real[3:10:2],
np.array([-6, 12, 0, 6], dtype=float))
assert_equal(lop * src_complex[3:10:2],
np.array([-6, 12, 0, 6], dtype=complex))
dst_real = 777 * np.ones((10, ), dtype=float)
dst_complex = np.array(dst_real, dtype=complex)
ref_real = np.array([777, 777, -6, 777, 12, 777, 0, 777, 6, 777],
dtype=float)
ref_complex = np.array(ref_real, dtype=complex)
lop(src_real[3:10:2], dst_real[2:9:2])
assert_equal(dst_real, ref_real)
lop(src_real[3:10:2], dst_complex[2:9:2])
assert_equal(dst_complex, ref_complex)
lop(src_complex[3:10:2], dst_complex[2:9:2])
assert_equal(dst_complex, ref_complex)
expr = 6j * c_dag("dn") - 6j * c("up")
hs = HilbertSpace(expr)
lop = LOperatorC(expr, hs)
ref_complex = np.array([777, 777, -6j, 777, 12j, 777, 0, 777, 6j, 777],
dtype=complex)
lop(src_real[3:10:2], dst_complex[2:9:2])
assert_equal(dst_complex, ref_complex)
lop(src_complex[3:10:2], dst_complex[2:9:2])
assert_equal(dst_complex, ref_complex)