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))