def weight_in_root_lattice(self): r""" Return the weight of ``self`` as an element of the root lattice. EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials(['F',4]) sage: m = M.module_generators[0].f_string([3,3,1,2,4]) sage: m.weight_in_root_lattice() -alpha[1] - alpha[2] - 2*alpha[3] - alpha[4] sage: M = crystals.infinity.NakajimaMonomials(['B',3,1]) sage: mg = M.module_generators[0] sage: m = mg.f_string([1,3,2,0,1,2,3,0,0,1]) sage: m.weight_in_root_lattice() -3*alpha[0] - 3*alpha[1] - 2*alpha[2] - 2*alpha[3] sage: M = crystals.infinity.NakajimaMonomials(['C',3,1]) sage: m = M.module_generators[0].f_string([3,0,1,2,0]) sage: m.weight_in_root_lattice() -2*alpha[0] - alpha[1] - alpha[2] - alpha[3] """ Q = RootSystem(self.parent().cartan_type()).root_lattice() al = Q.simple_roots() return Q.sum(e*al[k[0]] for k,e in six.iteritems(self._A))
def weight_in_root_lattice(self): r""" Return the weight of ``self`` as an element of the root lattice. EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials(['F',4]) sage: m = M.module_generators[0].f_string([3,3,1,2,4]) sage: m.weight_in_root_lattice() -alpha[1] - alpha[2] - 2*alpha[3] - alpha[4] sage: M = crystals.infinity.NakajimaMonomials(['B',3,1]) sage: mg = M.module_generators[0] sage: m = mg.f_string([1,3,2,0,1,2,3,0,0,1]) sage: m.weight_in_root_lattice() -3*alpha[0] - 3*alpha[1] - 2*alpha[2] - 2*alpha[3] sage: M = crystals.infinity.NakajimaMonomials(['C',3,1]) sage: m = M.module_generators[0].f_string([3,0,1,2,0]) sage: m.weight_in_root_lattice() -2*alpha[0] - alpha[1] - alpha[2] - alpha[3] """ Q = RootSystem(self.parent().cartan_type()).root_lattice() al = Q.simple_roots() return Q.sum(e * al[k[0]] for k, e in self._A.items())
def weight_in_root_lattice(self): r""" Return the weight of ``self`` as an element of the root lattice. EXAMPLES:: sage: M = crystals.infinity.NakajimaMonomials(['F',4]) sage: m = M.module_generators[0].f_string([3,3,1,2,4]) sage: m.weight_in_root_lattice() -alpha[1] - alpha[2] - 2*alpha[3] - alpha[4] sage: M = crystals.infinity.NakajimaMonomials(['B',3,1]) sage: mg = M.module_generators[0] sage: m = mg.f_string([1,3,2,0,1,2,3,0,0,1]) sage: m.weight_in_root_lattice() -3*alpha[0] - 3*alpha[1] - 2*alpha[2] - 2*alpha[3] """ Q = RootSystem(self.parent().cartan_type()).root_lattice() alpha = Q.simple_roots() path = self.to_highest_weight() return Q(sum(-alpha[j] for j in path[1]))
def weight_in_root_lattice(self): r""" Return the weight of ``self`` as an element of the root lattice. EXAMPLES:: sage: M = InfinityCrystalOfNakajimaMonomials(['F',4]) sage: m = M.module_generators[0].f_string([3,3,1,2,4]) sage: m.weight_in_root_lattice() -alpha[1] - alpha[2] - 2*alpha[3] - alpha[4] sage: M = InfinityCrystalOfNakajimaMonomials(['B',3,1]) sage: mg = M.module_generators[0] sage: m = mg.f_string([1,3,2,0,1,2,3,0,0,1]) sage: m.weight_in_root_lattice() -3*alpha[0] - 3*alpha[1] - 2*alpha[2] - 2*alpha[3] """ Q = RootSystem(self.parent().cartan_type()).root_lattice() alpha = Q.simple_roots() path = self.to_highest_weight() return Q(sum(-alpha[j] for j in path[1]))
def __init__(self, cartan_type, prefix, finite=True): r""" EXAMPLES:: sage: from sage.combinat.root_system.fundamental_group import FundamentalGroupOfExtendedAffineWeylGroup sage: F = FundamentalGroupOfExtendedAffineWeylGroup(['A',3,1]) sage: F in Groups().Commutative().Finite() True sage: TestSuite(F).run() """ def leading_support(beta): r""" Given a dictionary with one key, return this key """ supp = beta.support() assert len(supp) == 1 return supp[0] self._cartan_type = cartan_type self._prefix = prefix special_node = cartan_type.special_node() self._special_nodes = cartan_type.special_nodes() # initialize dictionaries with the entries for the # distinguished special node # dictionary of inverse elements inverse_dict = {} inverse_dict[special_node] = special_node # dictionary for the action of special automorphisms by # permutations of the affine Dynkin nodes auto_dict = {} for i in cartan_type.index_set(): auto_dict[special_node, i] = i # dictionary for the finite Weyl component of the special automorphisms reduced_words_dict = {} reduced_words_dict[0] = tuple([]) if cartan_type.dual().is_untwisted_affine(): # this combines the computations for an untwisted affine # type and its affine dual cartan_type = cartan_type.dual() if cartan_type.is_untwisted_affine(): cartan_type_classical = cartan_type.classical() I = [i for i in cartan_type_classical.index_set()] Q = RootSystem(cartan_type_classical).root_lattice() alpha = Q.simple_roots() omega = RootSystem( cartan_type_classical).weight_lattice().fundamental_weights() W = Q.weyl_group(prefix="s") for i in self._special_nodes: if i == special_node: continue antidominant_weight, reduced_word = omega[ i].to_dominant_chamber(reduced_word=True, positive=False) reduced_words_dict[i] = tuple(reduced_word) w0i = W.from_reduced_word(reduced_word) idual = leading_support(-antidominant_weight) inverse_dict[i] = idual auto_dict[i, special_node] = i for j in I: if j == idual: auto_dict[i, j] = special_node else: auto_dict[i, j] = leading_support(w0i.action(alpha[j])) self._action = Family( self._special_nodes, lambda i: Family(cartan_type.index_set(), lambda j: auto_dict[i, j])) self._dual_node = Family(self._special_nodes, inverse_dict.__getitem__) self._reduced_words = Family(self._special_nodes, reduced_words_dict.__getitem__) if finite: cat = Category.join( (Groups().Commutative().Finite(), EnumeratedSets())) else: cat = Groups().Commutative().Infinite() Parent.__init__(self, category=cat)
def product_on_basis(self, left, right): r""" Return ``left`` multiplied by ``right`` in ``self``. EXAMPLES:: sage: R = algebras.RationalCherednik(['A',2], 1, 1, QQ) sage: a2 = R.algebra_generators()['a2'] sage: ac1 = R.algebra_generators()['ac1'] sage: a2 * ac1 # indirect doctest a2*ac1 sage: ac1 * a2 -I + a2*ac1 - s1 - s2 + 1/2*s1*s2*s1 sage: x = R.an_element() sage: [y * x for y in R.some_elements()] [0, 3*ac1 + 2*s1 + a1, 9*ac1^2 + 10*I + 6*a1*ac1 + 6*s1 + 3/2*s2 + 3/2*s1*s2*s1 + a1^2, 3*a1*ac1 + 2*a1*s1 + a1^2, 3*a2*ac1 + 2*a2*s1 + a1*a2, 3*s1*ac1 + 2*I - a1*s1, 3*s2*ac1 + 2*s2*s1 + a1*s2 + a2*s2, 3*ac1^2 - 2*s1*ac1 + 2*I + a1*ac1 + 2*s1 + 1/2*s2 + 1/2*s1*s2*s1, 3*ac1*ac2 + 2*s1*ac1 + 2*s1*ac2 - I + a1*ac2 - s1 - s2 + 1/2*s1*s2*s1] sage: [x * y for y in R.some_elements()] [0, 3*ac1 + 2*s1 + a1, 9*ac1^2 + 10*I + 6*a1*ac1 + 6*s1 + 3/2*s2 + 3/2*s1*s2*s1 + a1^2, 6*I + 3*a1*ac1 + 6*s1 + 3/2*s2 + 3/2*s1*s2*s1 - 2*a1*s1 + a1^2, -3*I + 3*a2*ac1 - 3*s1 - 3*s2 + 3/2*s1*s2*s1 + 2*a1*s1 + 2*a2*s1 + a1*a2, -3*s1*ac1 + 2*I + a1*s1, 3*s2*ac1 + 3*s2*ac2 + 2*s1*s2 + a1*s2, 3*ac1^2 + 2*s1*ac1 + a1*ac1, 3*ac1*ac2 + 2*s1*ac2 + a1*ac2] """ # Make copies of the internal dictionaries dl = dict(left[2]._monomial) dr = dict(right[0]._monomial) # If there is nothing to commute if not dl and not dr: return self.monomial((left[0], left[1] * right[1], right[2])) R = self.base_ring() I = self._cartan_type.index_set() P = PolynomialRing(R, 'x', len(I)) G = P.gens() gens_dict = {a: G[i] for i, a in enumerate(I)} Q = RootSystem(self._cartan_type).root_lattice() alpha = Q.simple_roots() alphacheck = Q.simple_coroots() def commute_w_hd(w, al): # al is given as a dictionary ret = P.one() for k in al: x = sum(c * gens_dict[i] for i, c in alpha[k].weyl_action(w)) ret *= x**al[k] ret = ret.dict() for k in ret: yield (self._hd({I[i]: e for i, e in enumerate(k) if e != 0}), ret[k]) # Do Lac Ra if they are both non-trivial if dl and dr: il = dl.keys()[0] ir = dr.keys()[0] # Compute the commutator terms = self._product_coroot_root(il, ir) # remove the generator from the elements dl[il] -= 1 if dl[il] == 0: del dl[il] dr[ir] -= 1 if dr[ir] == 0: del dr[ir] # We now commute right roots past the left reflections: s Ra = Ra' s cur = self._from_dict({(hd, s * right[1], right[2]): c * cc for s, c in terms for hd, cc in commute_w_hd(s, dr)}) cur = self.monomial((left[0], left[1], self._h(dl))) * cur # Add back in the commuted h and hd elements rem = self.monomial((left[0], left[1], self._h(dl))) rem = rem * self.monomial( (self._hd({ir: 1}), self._weyl.one(), self._h({il: 1}))) rem = rem * self.monomial((self._hd(dr), right[1], right[2])) return cur + rem if dl: # We have La Ls Lac Rs Rac, # so we must commute Lac Rs = Rs Lac' # and obtain La (Ls Rs) (Lac' Rac) ret = P.one() for k in dl: x = sum(c * gens_dict[i] for i, c in alphacheck[k].weyl_action( right[1].reduced_word(), inverse=True)) ret *= x**dl[k] ret = ret.dict() w = left[1] * right[1] return self._from_dict({ (left[0], w, self._h({I[i]: e for i, e in enumerate(k) if e != 0}) * right[2]): ret[k] for k in ret }) # Otherwise dr is non-trivial and we have La Ls Ra Rs Rac, # so we must commute Ls Ra = Ra' Ls w = left[1] * right[1] return self._from_dict({(left[0] * hd, w, right[2]): c for hd, c in commute_w_hd(left[1], dr)})
def __init__(self, cartan_type, prefix, finite=True): r""" EXAMPLES:: sage: from sage.combinat.root_system.fundamental_group import FundamentalGroupOfExtendedAffineWeylGroup sage: F = FundamentalGroupOfExtendedAffineWeylGroup(['A',3,1]) sage: F in Groups().Commutative().Finite() True sage: TestSuite(F).run() """ def leading_support(beta): r""" Given a dictionary with one key, return this key """ supp = beta.support() assert len(supp) == 1 return supp[0] self._cartan_type = cartan_type self._prefix = prefix special_node = cartan_type.special_node() self._special_nodes = cartan_type.special_nodes() # initialize dictionaries with the entries for the distinguished special node # dictionary of inverse elements inverse_dict = {} inverse_dict[special_node] = special_node # dictionary for the action of special automorphisms by permutations of the affine Dynkin nodes auto_dict = {} for i in cartan_type.index_set(): auto_dict[special_node,i] = i # dictionary for the finite Weyl component of the special automorphisms reduced_words_dict = {} reduced_words_dict[0] = tuple([]) if cartan_type.dual().is_untwisted_affine(): # this combines the computations for an untwisted affine type and its affine dual cartan_type = cartan_type.dual() if cartan_type.is_untwisted_affine(): cartan_type_classical = cartan_type.classical() I = [i for i in cartan_type_classical.index_set()] Q = RootSystem(cartan_type_classical).root_lattice() alpha = Q.simple_roots() omega = RootSystem(cartan_type_classical).weight_lattice().fundamental_weights() W = Q.weyl_group(prefix="s") for i in self._special_nodes: if i == special_node: continue antidominant_weight, reduced_word = omega[i].to_dominant_chamber(reduced_word=True, positive=False) reduced_words_dict[i] = tuple(reduced_word) w0i = W.from_reduced_word(reduced_word) idual = leading_support(-antidominant_weight) inverse_dict[i] = idual auto_dict[i,special_node] = i for j in I: if j == idual: auto_dict[i,j] = special_node else: auto_dict[i,j] = leading_support(w0i.action(alpha[j])) self._action = Family(self._special_nodes, lambda i: Family(cartan_type.index_set(), lambda j: auto_dict[i,j])) self._dual_node = Family(self._special_nodes, inverse_dict.__getitem__) self._reduced_words = Family(self._special_nodes, reduced_words_dict.__getitem__) if finite: cat = Category.join((Groups().Commutative().Finite(),EnumeratedSets())) else: cat = Groups().Commutative().Infinite() Parent.__init__(self, category = cat)
def product_on_basis(self, left, right): r""" Return ``left`` multiplied by ``right`` in ``self``. EXAMPLES:: sage: R = algebras.RationalCherednik(['A',2], 1, 1, QQ) sage: a2 = R.algebra_generators()['a2'] sage: ac1 = R.algebra_generators()['ac1'] sage: a2 * ac1 # indirect doctest a2*ac1 sage: ac1 * a2 -I + a2*ac1 - s1 - s2 + 1/2*s1*s2*s1 sage: x = R.an_element() sage: [y * x for y in R.some_elements()] [0, 3*ac1 + 2*s1 + a1, 9*ac1^2 + 10*I + 6*a1*ac1 + 6*s1 + 3/2*s2 + 3/2*s1*s2*s1 + a1^2, 3*a1*ac1 + 2*a1*s1 + a1^2, 3*a2*ac1 + 2*a2*s1 + a1*a2, 3*s1*ac1 + 2*I - a1*s1, 3*s2*ac1 + 2*s2*s1 + a1*s2 + a2*s2, 3*ac1^2 - 2*s1*ac1 + 2*I + a1*ac1 + 2*s1 + 1/2*s2 + 1/2*s1*s2*s1, 3*ac1*ac2 + 2*s1*ac1 + 2*s1*ac2 - I + a1*ac2 - s1 - s2 + 1/2*s1*s2*s1] sage: [x * y for y in R.some_elements()] [0, 3*ac1 + 2*s1 + a1, 9*ac1^2 + 10*I + 6*a1*ac1 + 6*s1 + 3/2*s2 + 3/2*s1*s2*s1 + a1^2, 6*I + 3*a1*ac1 + 6*s1 + 3/2*s2 + 3/2*s1*s2*s1 - 2*a1*s1 + a1^2, -3*I + 3*a2*ac1 - 3*s1 - 3*s2 + 3/2*s1*s2*s1 + 2*a1*s1 + 2*a2*s1 + a1*a2, -3*s1*ac1 + 2*I + a1*s1, 3*s2*ac1 + 3*s2*ac2 + 2*s1*s2 + a1*s2, 3*ac1^2 + 2*s1*ac1 + a1*ac1, 3*ac1*ac2 + 2*s1*ac2 + a1*ac2] """ # Make copies of the internal dictionaries dl = dict(left[2]._monomial) dr = dict(right[0]._monomial) # If there is nothing to commute if not dl and not dr: return self.monomial((left[0], left[1] * right[1], right[2])) R = self.base_ring() I = self._cartan_type.index_set() P = PolynomialRing(R, 'x', len(I)) G = P.gens() gens_dict = {a:G[i] for i,a in enumerate(I)} Q = RootSystem(self._cartan_type).root_lattice() alpha = Q.simple_roots() alphacheck = Q.simple_coroots() def commute_w_hd(w, al): # al is given as a dictionary ret = P.one() for k in al: x = sum(c * gens_dict[i] for i,c in alpha[k].weyl_action(w)) ret *= x**al[k] ret = ret.dict() for k in ret: yield (self._hd({I[i]: e for i,e in enumerate(k) if e != 0}), ret[k]) # Do Lac Ra if they are both non-trivial if dl and dr: il = dl.keys()[0] ir = dr.keys()[0] # Compute the commutator terms = self._product_coroot_root(il, ir) # remove the generator from the elements dl[il] -= 1 if dl[il] == 0: del dl[il] dr[ir] -= 1 if dr[ir] == 0: del dr[ir] # We now commute right roots past the left reflections: s Ra = Ra' s cur = self._from_dict({ (hd, s*right[1], right[2]): c * cc for s,c in terms for hd, cc in commute_w_hd(s, dr) }) cur = self.monomial( (left[0], left[1], self._h(dl)) ) * cur # Add back in the commuted h and hd elements rem = self.monomial( (left[0], left[1], self._h(dl)) ) rem = rem * self.monomial( (self._hd({ir:1}), self._weyl.one(), self._h({il:1})) ) rem = rem * self.monomial( (self._hd(dr), right[1], right[2]) ) return cur + rem if dl: # We have La Ls Lac Rs Rac, # so we must commute Lac Rs = Rs Lac' # and obtain La (Ls Rs) (Lac' Rac) ret = P.one() for k in dl: x = sum(c * gens_dict[i] for i,c in alphacheck[k].weyl_action(right[1].reduced_word(), inverse=True)) ret *= x**dl[k] ret = ret.dict() w = left[1]*right[1] return self._from_dict({ (left[0], w, self._h({I[i]: e for i,e in enumerate(k) if e != 0}) * right[2] ): ret[k] for k in ret }) # Otherwise dr is non-trivial and we have La Ls Ra Rs Rac, # so we must commute Ls Ra = Ra' Ls w = left[1]*right[1] return self._from_dict({ (left[0] * hd, w, right[2]): c for hd, c in commute_w_hd(left[1], dr) })