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