def test_conformal_blocks_divisors(self):
liealg = cbd.TypeALieAlgebra(1)
cbb = cbd.ConformalBlocksBundle(liealg, [[1], [1], [1], [1]], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
self.assertEqual(1, cbb.get_norm_sym_divisor_ray()[0], "Divisor incorrect")
cbb = cbd.ConformalBlocksBundle(liealg, [[1], [1], [1], [1], [1], [1]], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(2, ray[0], "Divisor incorrect")
self.assertEqual(1, ray[1], "Divisor incorrect")
cbb = cbd.ConformalBlocksBundle(liealg, [[1], [1], [1], [1], [1], [1], [1], [1]], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(3, ray[0], "Divisor incorrect")
self.assertEqual(2, ray[1], "Divisor incorrect")
self.assertEqual(4, ray[2], "Divisor incorrect")
liealg = cbd.TypeALieAlgebra(5)
cbb = cbd.ConformalBlocksBundle(liealg, [[0,1,0,0,0],[0,1,0,0,0],[0,1,0,0,0],[0,1,0,0,0],[0,1,0,0,0],[0,1,0,0,0]], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(1, ray[0], "Divisor incorrect")
self.assertEqual(3, ray[1], "Divisor incorrect")
liealg = cbd.TypeALieAlgebra(6)
cbb = cbd.ConformalBlocksBundle(liealg, [[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0]], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(4, ray[0], "Divisor incorrect")
self.assertEqual(5, ray[1], "Divisor incorrect")
cbb = cbd.ConformalBlocksBundle(liealg,
[[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0]], 2)
self.assertEqual(7, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(1, ray[0], "Divisor incorrect")
self.assertEqual(3, ray[1], "Divisor incorrect")
cbb = cbd.ConformalBlocksBundle(liealg,
[[0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 0, 1, 0, 0, 0], [0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0]], 3)
self.assertEqual(8, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(0, ray[0], "Divisor incorrect")
self.assertEqual(0, ray[1], "Divisor incorrect")
liealg = cbd.TypeALieAlgebra(3)
cbb = cbd.ConformalBlocksBundle(liealg, [[0, 1, 4], [0, 1, 4], [1, 0, 1], [1, 0, 1], [1, 0, 1], [1, 0, 1]], 5)
self.assertEqual(10, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(8, ray[0], "Divisor incorrect")
self.assertEqual(9, ray[1], "Divisor incorrect")
def test_degree(self):
liealg = cbd.TypeALieAlgebra(1)
wt1 = tuple([1])
wt2 = tuple([3])
wt3 = tuple([5])
#self.assertEqual(1, liealg.degree(wt1,wt2,wt2,wt3, 5), "Degree incorrect")
#self.assertEqual(0, liealg.degree(wt1, wt2, wt2, wt3, 6), "Degree incorrect")
liealg = cbd.TypeALieAlgebra(4)
wt1 = tuple([0, 1, 0, 0])
wt2 = tuple([0, 0, 1, 0])
def test_conformal_blocks_ranks(self):
liealg = cbd.TypeALieAlgebra(3)
wt1 = tuple([0, 1, 4])
wt2 = tuple([1, 0, 2])
cbb = cbd.ConformalBlocksBundle(liealg, [wt1,wt1,wt2,wt2,wt2,wt2], 5)
self.assertEqual(99, cbb.get_rank(), "Rank incorrect")
liealg = cbd.TypeALieAlgebra(1)
wt1 = tuple([1])
cbb = cbd.ConformalBlocksBundle(liealg, [wt1,wt1,wt1,wt1,wt1,wt1,wt1,wt1,wt1,wt1], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
liealg = cbd.TypeALieAlgebra(2)
wt1 = tuple([0, 1])
cbb = cbd.ConformalBlocksBundle(liealg, [wt1,wt1,wt1,wt1,wt1,wt1,wt1,wt1,wt1], 2)
def test_sl4_orbit(self):
liealg = cbd.TypeALieAlgebra(3)
orbit = {(0, 0, 0)}
for wt in liealg.get_orbit_iter((0, 0, 0)):
self.assertTrue(wt in orbit)
orbit.remove(wt)
self.assertTrue(len(orbit) == 0)
orbit = {(1, 0, 0), (-1, 1, 0), (0, -1, 1), (0, 0, -1)}
for wt in liealg.get_orbit_iter((1, 0, 0)):
self.assertTrue(wt in orbit)
orbit.remove(wt)
self.assertTrue(len(orbit) == 0)
orbit = {(0, 1, 0), (1, -1, 1), (-1, 0, 1), (1, 0, -1), (-1, 1, -1),
(0, -1, 0)}
for wt in liealg.get_orbit_iter((0, 1, 0)):
self.assertTrue(wt in orbit)
orbit.remove(wt)
self.assertTrue(len(orbit) == 0)
orbit = {(0, 0, 1), (1, -1, 0), (0, 1, -1), (-1, 0, 0)}
for wt in liealg.get_orbit_iter((0, 0, 1)):
self.assertTrue(wt in orbit)
orbit.remove(wt)
self.assertTrue(len(orbit) == 0)
orbit = {(1, 0, 1), (-1, 1, 1), (1, 1, -1), (0, -1, 2), (-1, 2, -1),
(2, -1, 0), (0, 1, -2), (1, -2, 1), (-2, 1, 0), (1, -1, -1),
(-1, -1, 1), (-1, 0, -1)}
for wt in liealg.get_orbit_iter((1, 0, 1)):
self.assertTrue(wt in orbit)
orbit.remove(wt)
self.assertTrue(len(orbit) == 0)
def test_sl2_char(self):
liealg = cbd.TypeALieAlgebra(1)
wt = tuple([0])
self.assertEqual(1, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
wt = tuple([1])
self.assertEqual(2, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([1])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
wt = tuple([2])
self.assertEqual(3, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([2])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
char_wt = tuple([0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
def test_sl2_multi_fusion(self):
liealg = cbd.TypeALieAlgebra(1)
wt1 = tuple([0])
wt2 = tuple([1])
decomp = liealg.multi_fusion([wt1, wt2, wt2], 1)
dec_wt = tuple([2])
self.assertFalse(dec_wt in decomp, "Tensor decomp incorrect")
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.multi_fusion([wt2, wt2, wt2], 1)
dec_wt = tuple([1])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
wt1 = tuple([4])
wt2 = tuple([2])
decomp = liealg.multi_fusion([wt2, wt2, wt2], 4)
dec_wt = tuple([4])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([2])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(3, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
def test_sl2_weights(self):
liealg = cbd.TypeALieAlgebra(1)
wt = tuple([1])
self.assertItemsEqual([1, 0], liealg._convert_funds_to_epsilons(wt))
rt = cbd._Root(liealg, [1])
self.assertItemsEqual([2], rt)
self.assertItemsEqual([2, 0], liealg._convert_funds_to_epsilons(rt))
self.assertEqual(
1,
liealg.killing_form(wt, rt),
)
wt2 = tuple([-1])
self.assertItemsEqual([1], liealg.reflect_to_chamber(wt))
rt_list = liealg.get_positive_roots()
wt = tuple([0])
orbit_wt = wt
orbit_dict = {orbit_wt}
for wt2 in liealg.get_orbit_iter(wt):
self.assertTrue(wt2 in orbit_dict)
wt = tuple([-1])
orbit_wt1 = tuple([-1])
orbit_wt2 = tuple([1])
orbit_dict = {orbit_wt1, orbit_wt2}
for wt2 in liealg.get_orbit_iter(wt):
self.assertTrue(wt2 in orbit_dict)
def test_sl2_fusion(self):
liealg = cbd.TypeALieAlgebra(1)
decomp = liealg.fusion((0, ), (0, ), 1)
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.fusion((0, ), (1, ), 1)
dec_wt = tuple([1])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.fusion((1, ), (1, ), 1)
dec_wt = tuple([2])
self.assertFalse(dec_wt in decomp, "Tensor decomp incorrect")
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.fusion((1, ), (1, ), 2)
dec_wt = tuple([2])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.fusion((5, ), (2, ), 7)
dec_wt = tuple([7])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([5])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([3])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.fusion((5, ), (2, ), 6)
dec_wt = tuple([7])
self.assertFalse(dec_wt in decomp, "Tensor decomp incorrect")
dec_wt = tuple([5])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([3])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.fusion((5, ), (2, ), 5)
dec_wt = tuple([7])
self.assertFalse(dec_wt in decomp, "Tensor decomp incorrect")
dec_wt = tuple([5])
self.assertFalse(dec_wt in decomp and decomp[dec_wt] > 0,
"Tensor decomp incorrect")
dec_wt = tuple([3])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
def test_sl4_basic(self):
liealg = cbd.TypeALieAlgebra(3)
self.assertEqual([1, 0, 0, 0],
liealg._convert_funds_to_epsilons((1, 0, 0)))
self.assertEqual([1, 1, 0, 0],
liealg._convert_funds_to_epsilons((0, 1, 0)))
self.assertEqual([1, 1, 1, 0],
liealg._convert_funds_to_epsilons((0, 0, 1)))
self.assertEqual([3, 3, 1, 0],
liealg._convert_funds_to_epsilons((0, 2, 1)))
self.assertEqual((1, 0, 0),
liealg._convert_epsilons_to_funds([1, 0, 0, 0]))
self.assertEqual((0, 1, 0),
liealg._convert_epsilons_to_funds([1, 1, 0, 0]))
self.assertEqual((0, 0, 1),
liealg._convert_epsilons_to_funds([1, 1, 1, 0]))
self.assertEqual((1, 0, 0),
liealg._convert_epsilons_to_funds([1, 0, 0, 0]))
rt = cbd._Root(liealg, [1, 0, 0])
self.assertEqual((2, -1, 0), rt, "Fundamental coords incorrect")
rt = cbd._Root(liealg, [0, 1, 0])
self.assertEqual((-1, 2, -1), rt, "Fundamental coords incorrect")
rt = cbd._Root(liealg, [0, 0, 1])
self.assertEqual((0, -1, 2), rt, "Fundamental coords incorrect")
rt = cbd._Root(liealg, [1, 1, 0])
self.assertEqual((1, 1, -1), rt, "Fundamental coords incorrect")
self.assertEqual([1, 0, -1, 0], liealg._convert_funds_to_epsilons(rt),
"Epsilon coords incorrect")
wt = tuple([0, 2, 1])
self.assertEqual(2, liealg.killing_form(wt, rt),
"Killing product incorrect")
self.assertItemsEqual([1, 0, 1], liealg.reflect_to_chamber(rt),
"Reflection incorrect")
self.assertEqual(4, liealg.dual_coxeter())
roots = [(1, 0, 0), (0, 1, 0), (0, 0, 1), (1, 1, 0), (0, 1, 1),
(1, 1, 1)]
for rt in liealg.get_positive_roots():
self.assertTrue(tuple(rt.root_coords) in roots)
self.assertEqual(2, liealg.length_squared(rt))
roots.remove(tuple(rt.root_coords))
self.assertTrue(len(roots) == 0)
wt = liealg._convert_epsilons_to_funds([0, 0, 0, 1])
self.assertEqual(((1, 0, 0), -1),
liealg.reflect_to_chamber_with_parity(wt))
wt = liealg._convert_epsilons_to_funds([2, -1, 1, 0])
self.assertEqual(((1, 1, 1), 1),
liealg.reflect_to_chamber_with_parity(wt))
def test_F_curve(self):
liealg = cbd.TypeALieAlgebra(4)
wt = tuple([0, 1, 0, 0])
wt2 = tuple([0, 0, 1, 0])
wt3 = tuple([0, 0, 0, 1])
cbb = cbd.ConformalBlocksBundle(liealg, [wt, wt2, wt2, wt2, wt3], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
self.assertEqual(0, cbb.intersect_F_curve([[1, 2], [3], [4], [5]]), "F-curve intersection incorrect")
self.assertEqual(1, cbb.intersect_F_curve([[1], [2, 3], [4], [5]]), "F-curve intersection incorrect")
self.assertEqual(2, cbb.intersect_F_curve([[1], [2], [3], [4, 5]]), "F-curve intersection incorrect")
liealg = cbd.TypeALieAlgebra(6)
wt = tuple([0, 0, 1, 0, 0, 0])
wt2 = tuple([0, 0, 0, 1, 0, 0])
wt3 = tuple([0, 0, 0, 0, 0, 1])
cbb = cbd.ConformalBlocksBundle(liealg, [wt,wt2,wt2,wt2,wt3], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
self.assertEqual(1, cbb.intersect_F_curve([[1],[2,3],[4],[5]]), "F-curve intersection incorrect")
self.assertEqual(0, cbb.intersect_F_curve([[1, 2], [3], [4], [5]]), "F-curve intersection incorrect")
self.assertEqual(3, cbb.intersect_F_curve([[1], [2], [3], [4,5]]), "F-curve intersection incorrect")
def experiment():
rank = 3
level = 10
liealg = cbd.TypeALieAlgebra(rank, store_fusion=True, exact=False)
print("Weight", "Rank", "Divisor")
trivial_x = []
trivial_y = []
trivial_z = []
nontrivial_x = []
nontrivial_y = []
nontrivial_z = []
for wt in liealg.get_weights(level):
cbb = cbd.SymmetricConformalBlocksBundle(liealg, wt, 4, level)
if cbb.get_rank() == 0: continue
#tot_weight = wt.fund_coords[0] + 2*wt.fund_coords[1] + 3*wt.fund_coords[2]
#if tot_weight <= level: continue
#tot_weight = 3*wt.fund_coords[0] + 2*wt.fund_coords[1] + wt.fund_coords[2]
#if tot_weight <= level: continue
#if level >= tot_weight // (r+1): continue
divisor = cbb.get_symmetrized_divisor()
if divisor[0] == 0:
trivial_x.append(wt[0])
trivial_y.append(wt[2])
trivial_z.append(wt[1])
else:
nontrivial_x.append(wt[0])
nontrivial_y.append(wt[2])
nontrivial_z.append(wt[1])
print(wt, cbb.get_rank(), divisor[0])
# Plot the results
#fig, ax = plt.subplots()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
ax.scatter(trivial_x,
trivial_y,
zs=trivial_z,
c='black',
label="Trivial divisor")
ax.scatter(nontrivial_x,
nontrivial_y,
zs=nontrivial_z,
c='red',
label="Non-trivial divisor")
ax.set_xlabel('a_1')
ax.set_ylabel('a_3')
ax.set_zlabel('a_2')
ax.legend()
ax.grid(True)
plt.show()
def experiment():
rank = 5
level = 4
num_points = 10
liealg = cbd.TypeALieAlgebra(rank, store_fusion=True, exact=True)
print("Weight", "Rank", "Divisor")
for wt in liealg.get_weights(level):
cbb = cbd.SymmetricConformalBlocksBundle(liealg, wt, num_points, level)
if cbb.get_rank() == 0:
#print(wt, 0, 0)
continue
divisor = cbb.get_symmetrized_divisor()
print(wt, cbb.get_rank(), divisor)
def test_sl4_char(self):
liealg = cbd.TypeALieAlgebra(3)
wt = tuple([0, 0, 0])
self.assertEqual(1, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([0, 0, 0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
wt = tuple([1, 0, 0])
self.assertEqual(4, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([1, 0, 0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
wt = tuple([0, 0, 1])
self.assertEqual(4, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([1, 0, 0])
self.assertFalse(char_wt in dom_char, "Character incorrect")
char_wt = tuple([0, 0, 1])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
wt = tuple([0, 1, 0])
self.assertEqual(6, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([0, 1, 0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
wt = tuple([1, 1, 1])
self.assertEqual(64, liealg.get_rep_dim(wt), "Dimension not correct")
dom_char = liealg.get_dominant_character(wt)
char_wt = tuple([1, 1, 1])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(1, dom_char[char_wt], "Character incorrect")
char_wt = tuple([2, 0, 0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(2, dom_char[char_wt], "Character incorrect")
char_wt = tuple([0, 1, 0])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(4, dom_char[char_wt], "Character incorrect")
char_wt = tuple([0, 0, 2])
self.assertTrue(char_wt in dom_char, "Character incorrect")
self.assertEqual(2, dom_char[char_wt], "Character incorrect")
def test_symmetric_divisors(self):
liealg = cbd.TypeALieAlgebra(1)
cbb = cbd.SymmetricConformalBlocksBundle(liealg, [1], 4, 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
self.assertEqual(1, cbb.get_norm_sym_divisor_ray()[0], "Divisor incorrect")
cbb = cbd.SymmetricConformalBlocksBundle(liealg, [1], 6, 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(2, ray[0], "Divisor incorrect")
self.assertEqual(1, ray[1], "Divisor incorrect")
cbb = cbd.SymmetricConformalBlocksBundle(liealg, [1], 8, 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
self.assertEqual(3, ray[0], "Divisor incorrect")
self.assertEqual(2, ray[1], "Divisor incorrect")
self.assertEqual(4, ray[2], "Divisor incorrect")
cbb = cbd.SymmetricConformalBlocksBundle(liealg, [1], 10, 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect")
ray = cbb.get_norm_sym_divisor_ray()
def test_sl2_tensor(self):
liealg = cbd.TypeALieAlgebra(1)
decomp = liealg.tensor((0, ), (0, ))
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.tensor((0, ), (1, ))
dec_wt = tuple([1])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.tensor((1, ), (1, ))
dec_wt = tuple([2])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([0])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.tensor((2, ), (1, ))
dec_wt = tuple([3])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([1])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
decomp = liealg.tensor((5, ), (2, ))
dec_wt = tuple([7])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([5])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
dec_wt = tuple([3])
self.assertTrue(dec_wt in decomp, "Tensor decomp incorrect")
self.assertEqual(1, decomp[dec_wt], "Tensor decomp incorrect")
def experiment():
"""
Computes the rank and divisor of conformal block bundles with random weights.
:return: Null
"""
rank = 5
level = 3
num_points = 10
tries = 100
liealg = cbd.TypeALieAlgebra(rank, store_fusion=True, exact=False)
A_l = liealg.get_weights(level)
print("Weight", "Rank", "Divisor")
for i in range(tries):
weights = [random.choice(A_l) for i in range(num_points)]
if sum([sum(liealg._convert_funds_to_epsilons(wt))
for wt in weights]) % (rank + 1) != 0:
continue
cbb = cbd.ConformalBlocksBundle(liealg, weights, level)
if cbb.get_rank() > 0:
divisor = cbb.get_symmetrized_divisor()
print(weights, cbb.get_rank(), divisor)
else:
print(weights, cbb.get_rank(), 0)
def test_A1N5(self):
#Level 1
liealg = cbd.TypeALieAlgebra(1)
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (0,), (0,), (1,), (0,)], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(1,), (0,), (0,), (1,), (0,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (0,), (1,), (0,), (0,)], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(1,), (0,), (1,), (0,), (0,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (1,), (0,), (0,), (1,)], 1)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1,), (1,), (0,), (0,), (1,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (0,), (1,), (0,), (0,)], 1)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (0,), (1,), (0,), (0,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (0,), (0,), (1,), (1,)], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(0,), (0,), (0,), (1,), (1,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (0,), (0,), (1,), (0,)], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(1,), (0,), (0,), (1,), (0,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (0,), (0,), (0,), (1,)], 1)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (0,), (0,), (0,), (1,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (1,), (0,), (0,), (1,)], 1)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1,), (1,), (0,), (0,), (1,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (1,), (0,), (0,), (0,)], 1)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (1,), (0,), (0,), (0,)], 1)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (0,), (1,), (1,), (0,)], 1)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(0,), (0,), (1,), (1,), (0,)], 1)")
#Level 2
liealg = cbd.TypeALieAlgebra(1)
cbb = cbd.ConformalBlocksBundle(liealg, [(2,), (0,), (0,), (2,), (0,)], 2)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(2,), (0,), (0,), (2,), (0,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (1,), (1,), (1,), (2,)], 2)
self.assertEqual(2, cbb.get_rank(), "Rank incorrect: ([(1,), (1,), (1,), (1,), (2,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (0,), (2,), (0,), (2,)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1,), (0,), (2,), (0,), (2,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (2,), (2,), (1,), (2,)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (2,), (2,), (1,), (2,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (2,), (1,), (1,), (1,)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (2,), (1,), (1,), (1,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(2,), (2,), (1,), (2,), (1,)], 2)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(2,), (2,), (1,), (2,), (1,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(2,), (2,), (2,), (1,), (0,)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(2,), (2,), (2,), (1,), (0,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(2,), (1,), (1,), (0,), (2,)], 2)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(2,), (1,), (1,), (0,), (2,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(2,), (1,), (1,), (1,), (0,)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(2,), (1,), (1,), (1,), (0,)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (0,), (2,), (2,), (2,)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (0,), (2,), (2,), (2,)], 2)")
#Level 3
liealg = cbd.TypeALieAlgebra(1)
cbb = cbd.ConformalBlocksBundle(liealg, [(3,), (1,), (1,), (2,), (1,)], 3)
self.assertEqual(2, cbb.get_rank(), "Rank incorrect: ([(3,), (1,), (1,), (2,), (1,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (0,), (0,), (3,), (2,)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (0,), (0,), (3,), (2,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (1,), (2,), (3,), (1,)], 3)
self.assertEqual(2, cbb.get_rank(), "Rank incorrect: ([(1,), (1,), (2,), (3,), (1,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (2,), (1,), (2,), (1,)], 3)
self.assertEqual(2, cbb.get_rank(), "Rank incorrect: ([(0,), (2,), (1,), (2,), (1,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(2,), (0,), (3,), (2,), (2,)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(2,), (0,), (3,), (2,), (2,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (1,), (0,), (1,), (2,)], 3)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(0,), (1,), (0,), (1,), (2,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (1,), (2,), (0,), (1,)], 3)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(0,), (1,), (2,), (0,), (1,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (3,), (3,), (1,), (3,)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (3,), (3,), (1,), (3,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1,), (2,), (3,), (2,), (0,)], 3)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(1,), (2,), (3,), (2,), (0,)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0,), (3,), (3,), (1,), (2,)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0,), (3,), (3,), (1,), (2,)], 3)")
def test_A2N6(self):
#Level 2
liealg = cbd.TypeALieAlgebra(2)
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 1), (2, 0), (0, 1), (2, 0), (0, 0), (0, 2)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 1), (2, 0), (0, 1), (2, 0), (0, 0), (0, 2)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 1), (0, 2), (0, 1), (1, 0), (0, 1), (0, 2)], 2)
self.assertEqual(2, cbb.get_rank(), "Rank incorrect: ([(0, 1), (0, 2), (0, 1), (1, 0), (0, 1), (0, 2)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(2, 0), (0, 2), (0, 1), (1, 1), (1, 1), (1, 1)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(2, 0), (0, 2), (0, 1), (1, 1), (1, 1), (1, 1)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 2), (2, 0), (0, 2), (2, 0), (2, 0), (1, 1)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0, 2), (2, 0), (0, 2), (2, 0), (2, 0), (1, 1)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 1), (2, 0), (2, 0), (0, 2), (1, 0), (1, 0)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 1), (2, 0), (2, 0), (0, 2), (1, 0), (1, 0)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 0), (1, 1), (1, 0), (0, 1), (0, 2), (0, 0)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0, 0), (1, 1), (1, 0), (0, 1), (0, 2), (0, 0)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 0), (2, 0), (0, 0), (1, 0), (1, 1), (2, 0)], 2)
self.assertEqual(1, cbb.get_rank(), "Rank incorrect: ([(1, 0), (2, 0), (0, 0), (1, 0), (1, 1), (2, 0)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 2), (0, 2), (0, 2), (0, 1), (0, 1), (0, 0)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0, 2), (0, 2), (0, 2), (0, 1), (0, 1), (0, 0)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 1), (0, 1), (0, 0), (0, 1), (1, 0), (1, 0)], 2)
self.assertEqual(3, cbb.get_rank(), "Rank incorrect: ([(1, 1), (0, 1), (0, 0), (0, 1), (1, 0), (1, 0)], 2)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 0), (1, 0), (2, 0), (0, 1), (1, 1), (1, 0)], 2)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 0), (1, 0), (2, 0), (0, 1), (1, 1), (1, 0)], 2)")
#Level 3
liealg = cbd.TypeALieAlgebra(2)
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 0), (2, 0), (1, 0), (1, 1), (1, 0), (0, 1)], 3)
self.assertEqual(4, cbb.get_rank(), "Rank incorrect: ([(0, 0), (2, 0), (1, 0), (1, 1), (1, 0), (0, 1)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 0), (1, 0), (2, 1), (0, 2), (1, 1), (3, 0)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 0), (1, 0), (2, 1), (0, 2), (1, 1), (3, 0)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 2), (1, 2), (0, 1), (0, 3), (0, 1), (1, 1)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 2), (1, 2), (0, 1), (0, 3), (0, 1), (1, 1)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 1), (0, 2), (2, 0), (2, 1), (1, 2), (0, 2)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 1), (0, 2), (2, 0), (2, 1), (1, 2), (0, 2)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 3), (1, 0), (1, 2), (3, 0), (0, 3), (0, 2)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0, 3), (1, 0), (1, 2), (3, 0), (0, 3), (0, 2)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 2), (0, 1), (1, 0), (1, 2), (0, 3), (0, 2)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(1, 2), (0, 1), (1, 0), (1, 2), (0, 3), (0, 2)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 1), (1, 2), (2, 0), (2, 1), (0, 3), (0, 1)], 3)
self.assertEqual(3, cbb.get_rank(), "Rank incorrect: ([(0, 1), (1, 2), (2, 0), (2, 1), (0, 3), (0, 1)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(1, 1), (1, 1), (0, 2), (0, 2), (0, 0), (1, 0)], 3)
self.assertEqual(6, cbb.get_rank(), "Rank incorrect: ([(1, 1), (1, 1), (0, 2), (0, 2), (0, 0), (1, 0)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 1), (3, 0), (3, 0), (0, 0), (0, 2), (1, 0)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0, 1), (3, 0), (3, 0), (0, 0), (0, 2), (1, 0)], 3)")
cbb = cbd.ConformalBlocksBundle(liealg, [(0, 2), (2, 0), (3, 0), (1, 2), (0, 1), (2, 1)], 3)
self.assertEqual(0, cbb.get_rank(), "Rank incorrect: ([(0, 2), (2, 0), (3, 0), (1, 2), (0, 1), (2, 1)], 3)")
def test_A3N6(self):
liealg = cbd.TypeALieAlgebra(3)
cbb = cbd.ConformalBlocksBundle(liealg,
[(0, 2, 0), (0, 1, 1), (0, 0, 1),
(1, 1, 0), (0, 0, 1), (0, 1, 1)], 2)
f_curve = [(6, ), (1, ), (2, 3, 4), (5, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(2, 0, 0), (0, 0, 2), (0, 0, 1),
(2, 0, 0), (1, 0, 0), (0, 0, 1)], 2)
f_curve = [(5, 6), (2, 3), (4, ), (1, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(0, 1, 1), (1, 0, 1), (0, 1, 0),
(1, 1, 0), (0, 0, 2), (0, 0, 1)], 2)
f_curve = [(2, 3), (4, ), (1, 6), (5, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(1, 0, 1), (0, 1, 1), (1, 0, 0),
(1, 1, 0), (0, 0, 2), (0, 2, 0)], 2)
f_curve = [(4, ), (5, ), (1, 3), (2, 6)]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(0, 0, 0), (0, 1, 1), (0, 0, 2),
(0, 1, 1), (1, 0, 1), (0, 1, 1)], 2)
f_curve = [(6, ), (1, ), (3, 4, 5), (2, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(0, 1, 0), (0, 2, 0), (0, 0, 2),
(1, 0, 1), (0, 1, 1), (0, 0, 1)], 2)
f_curve = [(1, 3), (2, ), (5, ), (4, 6)]
self.assertEqual(3, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(2, 0, 0), (0, 1, 0), (1, 0, 1),
(1, 0, 1), (1, 0, 0), (0, 0, 1)], 2)
f_curve = [(3, ), (4, ), (1, 2), (5, 6)]
self.assertEqual(3, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(0, 0, 1), (0, 1, 1), (1, 0, 0),
(0, 0, 0), (0, 0, 0), (0, 2, 0)], 2)
f_curve = [(1, 4), (3, ), (2, 5), (6, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(1, 1, 0), (0, 1, 1), (2, 0, 0),
(0, 0, 0), (1, 1, 0), (0, 2, 0)], 2)
f_curve = [(2, 4), (1, ), (3, 5), (6, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))
cbb = cbd.ConformalBlocksBundle(liealg,
[(0, 0, 1), (0, 0, 0), (0, 0, 0),
(0, 0, 2), (0, 1, 1), (0, 2, 0)], 2)
f_curve = [(3, 5), (1, 2), (6, ), (4, )]
self.assertEqual(0, cbb.intersect_F_curve(f_curve))