def __classcall_private__(cls, crystals, weight): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: B = crystals.KirillovReshetikhin(['A',2,1], 1,1) sage: L = RootSystem(['A',2,1]).weight_lattice() sage: C = crystals.KyotoPathModel(B, L.fundamental_weight(0)) sage: C2 = crystals.KyotoPathModel((B,), L.fundamental_weight(0)) sage: C3 = crystals.KyotoPathModel([B], L.fundamental_weight(0)) sage: C is C2 and C2 is C3 True sage: L = RootSystem(['A',2,1]).weight_space() sage: C = KyotoPathModel(B, L.fundamental_weight(0)) Traceback (most recent call last): ... ValueError: Lambda[0] is not in the weight lattice """ if isinstance(crystals, list): crystals = tuple(crystals) elif not isinstance(crystals, tuple): crystals = (crystals, ) if any(not B.is_perfect() for B in crystals): raise ValueError("all crystals must be perfect") level = crystals[0].level() if any(B.level() != level for B in crystals[1:]): raise ValueError("all crystals must have the same level") ct = crystals[0].cartan_type() P = RootSystem(ct).weight_lattice() if weight.parent() is not P: raise ValueError("{} is not in the weight lattice".format(weight)) if sum(ct.dual().c()[i] * weight.scalar(h) for i, h in enumerate(P.simple_coroots())) != level: raise ValueError("{} is not a level {} weight".format( weight, level)) return super(KyotoPathModel, cls).__classcall__(cls, crystals, weight)
def __classcall_private__(cls, crystals, weight): """ Normalize input to ensure a unique representation. EXAMPLES:: sage: B = crystals.KirillovReshetikhin(['A',2,1], 1,1) sage: L = RootSystem(['A',2,1]).weight_lattice() sage: C = crystals.KyotoPathModel(B, L.fundamental_weight(0)) sage: C2 = crystals.KyotoPathModel((B,), L.fundamental_weight(0)) sage: C3 = crystals.KyotoPathModel([B], L.fundamental_weight(0)) sage: C is C2 and C2 is C3 True sage: L = RootSystem(['A',2,1]).weight_space() sage: C = KyotoPathModel(B, L.fundamental_weight(0)) Traceback (most recent call last): ... ValueError: Lambda[0] is not in the weight lattice """ if isinstance(crystals, list): crystals = tuple(crystals) elif not isinstance(crystals, tuple): crystals = (crystals,) if any(not B.is_perfect() for B in crystals): raise ValueError("all crystals must be perfect") level = crystals[0].level() if any(B.level() != level for B in crystals[1:]): raise ValueError("all crystals must have the same level") ct = crystals[0].cartan_type() P = RootSystem(ct).weight_lattice() if weight.parent() is not P: raise ValueError("{} is not in the weight lattice".format(weight)) if sum( ct.dual().c()[i] * weight.scalar(h) for i,h in enumerate(P.simple_coroots()) ) != level: raise ValueError( "{} is not a level {} weight".format(weight, level) ) return super(KyotoPathModel, cls).__classcall__(cls, crystals, weight)
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 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) })