def testGeneratesAllElementsA2(self): group = c.generate_a2() expected_lookup = { p.Permutation([1, 2, 3]): 'e', p.Permutation([2, 1, 3]): 'r', p.Permutation([1, 3, 2]): 's', p.Permutation([2, 3, 1]): 'rs', p.Permutation([3, 1, 2]): 'sr', p.Permutation([3, 2, 1]): 'rsr' } self.assertEqual(group.name_lookup, expected_lookup) e = group['e'] r = group['r'] s = group['s'] rs = group['rs'] sr = group['sr'] rsr = group['rsr'] self.assertEqual(r * r, e) self.assertEqual(s * s, e) self.assertEqual(r * s, rs) self.assertEqual(s * r, sr) self.assertEqual(sr * r, s) self.assertEqual(rs * s, r) self.assertEqual(s * sr, r) self.assertEqual(r * rs, s) self.assertEqual(r * s * r, rsr) self.assertEqual(s * r * s, rsr) self.assertEqual(rs * r, rsr) self.assertEqual(r * sr, rsr) self.assertEqual(s * rs, rsr) self.assertEqual(sr * s, rsr)
def test_mult_int(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) element = hecke.element({ 'e': l.Laurent({ -100: 20, 0: 10, 100: 20 }), 'rsr': l.Laurent({ -25: -12, -2: -1, 2: 2 }) }) result = element * 3 expected_result = hecke.element({ 'e': l.Laurent({ -100: 60, 0: 30, 100: 60 }), 'rsr': l.Laurent({ -25: -36, -2: -3, 2: 6 }) }) self.assertEqual(result, expected_result)
def test_sub(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) h1 = hecke.element({'s': l.Laurent({-1: 1, 1: 1})}) h2 = hecke.element({ 'e': l.Laurent({-3: 5}), 's': l.Laurent({ 0: 1, 1: 4 }) }) h3 = hecke.element(({ 'e': l.Laurent({-3: -5}), 's': l.Laurent({ -1: 1, 0: -1, 1: -3 }) })) self.assertEqual(h1 - h1, hecke.zero) self.assertEqual(h2 - h2, hecke.zero) self.assertEqual(h1 - h2, h3)
def test_get_inverse(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) self.assertEqual( hecke.get_standard_basis_element('e') * hecke.get_generator_inverse_element('e'), hecke.one) self.assertEqual( hecke.get_standard_basis_element('r') * hecke.get_generator_inverse_element('r'), hecke.one) self.assertEqual( hecke.get_standard_basis_element('s') * hecke.get_generator_inverse_element('s'), hecke.one) self.assertEqual( hecke.get_standard_basis_element('rs') * hecke.get_standard_inverse_element('rs'), hecke.one) self.assertEqual( hecke.get_standard_basis_element('sr') * hecke.get_standard_inverse_element('sr'), hecke.one) self.assertEqual( hecke.get_standard_basis_element('rsr') * hecke.get_standard_inverse_element('rsr'), hecke.one)
def test_i(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) for element in group.all_elements(): self.assertEqual( hecke.get_standard_basis_element(element.name).i(), hecke.get_standard_basis_element(element.inverse().name))
def test_index(self): group = c.generate_a2() self.assertEqual(group['e'].index, 0) self.assertEqual(group['r'].index, 1) self.assertEqual(group['s'].index, 2) self.assertEqual(group['rs'].index, 3) self.assertEqual(group['sr'].index, 4) self.assertEqual(group['rsr'].index, 5)
def test_longest(self): a1 = c.generate_a1() self.assertEqual(a1.longest.name, "s") a2 = c.generate_a2() self.assertEqual(a2.longest.name, "rsr") a3 = c.generate_a3() self.assertEqual(a3.longest.name, "rsrtsr")
def testLength(self): group = c.generate_a2() self.assertEqual(group['e'].length(), 0) self.assertEqual(group['r'].length(), 1) self.assertEqual(group['s'].length(), 1) self.assertEqual(group['rs'].length(), 2) self.assertEqual(group['sr'].length(), 2) self.assertEqual(group['rsr'].length(), 3)
def test_generate_kl_basis(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) kl_basis = hecke.generate_kl_basis() for name in group.elements.keys(): self.assertEqual(kl_basis[name], kl_basis[name].dual()) self.assert_positive(kl_basis[name], name)
def test_mult_laurent(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) l1 = l.Laurent({0: 1, 1: -1}) l2 = l.Laurent({-2: 10, 3: 5}) element = hecke.element({'e': l1}) result = element * l2 expected_result = hecke.element({'e': l1 * l2}) self.assertEqual(result, expected_result)
def test_dual_kl_basis(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) dual_kl_basis = hecke.generate_dual_kl_basis() for x in group.elements.keys(): hx = hecke.get_standard_basis_element(x) hxkl = hx.in_dual_kl_basis() ress = hecke.zero for element, coef in hxkl.items(): ress += dual_kl_basis[element] * coef self.assertEqual(hx, ress)
def test_filtration_string(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) kl_basis = hecke.generate_kl_basis() dual_kl_basis = hecke.generate_dual_kl_basis() self.assertEqual(dual_kl_basis['e'].dual_kl_filtration(), 'e\n') self.assertEqual( hecke.get_standard_basis_element('e').dual_kl_filtration(), (" e \n" " r s \n" "rs sr\n" " rsr \n"))
def test_w0_central(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) w0 = hecke.element({'rsr': l.Laurent({0: 1})}) w02 = w0 * w0 h1 = hecke.element({ 'e': l.Laurent({1: 2}), 'sr': l.Laurent({ -10: 20, 2: 1 }) }) h2 = hecke.element({'e': l.Laurent({0: 1})}) self.assertEqual(w02 * h1, h1 * w02) self.assertEqual(w02 * h2, h2 * w02)
def test_orders(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) left, right = hecke.generate_orders() # e, s, r, sr, rs, rsr expected_right = np.array( [[1, 0, 0, 0, 0, 0], [1, 1, 0, 1, 0, 0], [1, 0, 1, 0, 1, 0], [1, 1, 0, 1, 0, 0], [1, 0, 1, 0, 1, 0], [1, 1, 1, 1, 1, 1]], dtype=bool) expected_left = np.array( [[1, 0, 0, 0, 0, 0], [1, 1, 0, 0, 1, 0], [1, 0, 1, 1, 0, 0], [1, 0, 1, 1, 0, 0], [1, 1, 0, 0, 1, 0], [1, 1, 1, 1, 1, 1]], dtype=bool) np.testing.assert_array_equal(right, expected_right)
def test_dual(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) self.assertEqual( hecke.get_standard_basis_element('e').dual().dual(), hecke.get_standard_basis_element('e')) self.assertEqual( hecke.get_standard_basis_element('r').dual().dual(), hecke.get_standard_basis_element('r')) self.assertEqual( hecke.get_standard_basis_element('s').dual().dual(), hecke.get_standard_basis_element('s')) self.assertEqual( hecke.get_standard_basis_element('rs').dual().dual(), hecke.get_standard_basis_element('rs')) self.assertEqual( hecke.get_standard_basis_element('sr').dual().dual(), hecke.get_standard_basis_element('sr')) self.assertEqual( hecke.get_standard_basis_element('rsr').dual().dual(), hecke.get_standard_basis_element('rsr')) h1 = hecke.element({ 'e': l.Laurent({ -1: 10, 2: 3 }), 's': l.Laurent({ 0: 1, 1: 3 }), 'rsr': l.Laurent({20: -12}) }) self.assertEqual(h1.dual().dual(), h1) hs = hecke.element({'e': l.Laurent({1: 1}), 's': l.Laurent({0: 1})}) self.assertEqual(hs.dual(), hs) print(hs * hs) self.assertEqual(hs * hs, hs * l.Laurent({-1: 1, 1: 1}))
def test_mul_generator(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) e = hecke.element({'e': l.Laurent({0: 1})}) r = hecke.element({'r': l.Laurent({0: 1})}) s = hecke.element({'s': l.Laurent({0: 1})}) rs = hecke.element({'rs': l.Laurent({0: 1})}) sr = hecke.element({'sr': l.Laurent({0: 1})}) rsr = hecke.element({'rsr': l.Laurent({0: 1})}) self.assertEqual(e * s, s) self.assertEqual(e * r, r) self.assertEqual(r * s, rs) self.assertEqual(s * r, sr) self.assertEqual(r * s * r, rsr) self.assertEqual(rs * r, rsr) self.assertEqual(r * sr, rsr) self.assertEqual(sr * s, rsr) self.assertEqual( s * s, hecke.element({ 's': l.Laurent({ -1: 1, 1: -1 }), 'e': l.Laurent({0: 1}) })) self.assertEqual( sr * r, hecke.element({ 'sr': l.Laurent({ -1: 1, 1: -1 }), 's': l.Laurent({0: 1}) })) self.assertEqual( hecke.element({'r': l.Laurent({0: 2})}) * hecke.element({'sr': l.Laurent({0: 2})}), hecke.element({'rsr': l.Laurent({0: 4})}))
def test_generate_dual_kl_basis(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) kl_basis = hecke.generate_kl_basis() dual_kl_basis = hecke.generate_dual_kl_basis() for x in group.elements.values(): kl_x = kl_basis[x.name] for y in group.elements.values(): dkl_y = dual_kl_basis[y.name] if x == y.inverse(): self.assertEqual((kl_x * dkl_y).tau(), l.one) self.assertEqual((dkl_y * kl_x).tau(), l.one) else: self.assertEqual((kl_x * dkl_y).tau(), l.zero) self.assertEqual((dkl_y * kl_x).tau(), l.zero) for name in group.elements.keys(): self.assertEqual(kl_basis[name], kl_basis[name].dual()) self.assert_positive(kl_basis[name], name)
def test_add(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) h1 = hecke.element({'s': l.Laurent({-1: 1, 1: 1})}) h2 = hecke.element({ 'e': l.Laurent({-3: 5}), 's': l.Laurent({ 0: 1, 1: 4 }) }) expected_sum = hecke.element({ 'e': l.Laurent({-3: 5}), 's': l.Laurent({ -1: 1, 0: 1, 1: 5 }) }) self.assertEqual(h1 + h2, expected_sum)
def test_mul_identity(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) e = hecke.element({'e': l.Laurent({0: 1})}) self.assertEqual(e * e, e) h1 = hecke.element({ 's': l.Laurent({ 10: 1, 20: 2 }), 'rs': l.Laurent({ -1: 2, 0: 1 }) }) self.assertEqual(h1 * e, h1) h2 = hecke.element({ 'e': l.Laurent({ -100: 20, 0: 10, 100: 20 }), 'rsr': l.Laurent({ -25: -12, -2: -1, 2: 2 }) }) self.assertEqual(h2 * e, h2) self.assertEqual(e * h2, h2)
def test_basis_matrix(self): group = c.generate_a2() hecke = h.HeckeAlgebra(group) standard_basis = [ (x, hecke.get_standard_basis_element(x)) for x in sorted(group.elements.keys(), key=lambda x: (len(x), x)) ] ret = hecke.basis_matrix(standard_basis, hecke.generate_dual_kl_basis()) expected = [[1, 1, 1, 1, 1, 1], [0, 1, 0, 1, 1, 1], [0, 0, 1, 1, 1, 1], [0, 0, 0, 1, 0, 1], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1]] self.assertEquals(ret, expected) group = c.generate_a3() hecke = h.HeckeAlgebra(group) kl_basis = hecke.generate_kl_basis() dual_kl_basis = hecke.generate_dual_kl_basis() d = dict() for element in ['e', 's', 'sr', 'st']: d[element] = (dual_kl_basis['s'] * kl_basis[element]).in_dual_kl_basis() ret = hecke.matrix(d) expected = [[ 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 1, 0, 2, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]] self.assertEqual(ret, expected)
def testInverse(self): group = c.generate_a2() for element in group.elements.values(): self.assertEqual(element * element.inverse(), group.identity) self.assertEqual(element.inverse() * element, group.identity)