Hecke algebra representations¶
-
class
sage.combinat.root_system.hecke_algebra_representation.
CherednikOperatorsEigenvectors
(T, T_Y=None, normalized=True)¶ Bases:
sage.structure.unique_representation.UniqueRepresentation
,sage.structure.sage_object.SageObject
A class for the family of eigenvectors of the
Cherednik operators for a module over a (Double) Affine Hecke algebra
INPUT:
T
– a familyimplementing the action of the generators of an affine Hecke algebra on
self
. The intertwiner operators are built from these.T_Y
– a familyimplementing the action of the generators of an affine Hecke algebra on
self
. By default, this isT
. But this can be used to get the action of the full Double Affine Hecke Algebra. Theoperators are built from the
T_Y
.
This returns a function
which uses intertwining operators to calculate recursively eigenvectors
for the action of the torus of the affine Hecke algebra with eigenvalue given by
. Namely:
Assumptions:
seed(mu)
initializes the recurrence by returning an appropriate eigenvectorfor
trivial enough. For example, for nonsymmetric Macdonald polynomials
seed(mu)
returns the monomialfor a minuscule weight
.
is almost equivariant. Namely,
whenever
is a descent of
.
maps
closer to the dominant chamber whenever
is a descent of
.
Todo
Add tests for the above assumptions, and also that the classical operators
from
and
coincide.
-
Y
()¶ Return the Cherednik operators.
EXAMPLES:
sage: W = WeylGroup(["B",2]) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: E.Y() Lazy family (...)_{i in Coroot lattice of the Root system of type ['B', 2, 1]}
-
affine_lift
(mu)¶ Lift the index
\mu
to a space admitting an action of the affine Weyl group.INPUT:
mu
– an elementof the indexing set
In this space, one should have
first_descent
andapply_simple_reflection
act properly.EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: w = W.an_element(); w 123 sage: E.affine_lift(w) 121
-
affine_retract
(mu)¶ Retract
from a space admitting an action of the affine Weyl group.
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: w = W.an_element(); w 123 sage: E.affine_retract(E.affine_lift(w)) == w True
-
cartan_type
()¶ Return Cartan type of
self
.EXAMPLES:
sage: W = WeylGroup(["B",3]) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: E.cartan_type() ['B', 3, 1] sage: NonSymmetricMacdonaldPolynomials(["B", 2, 1]).cartan_type() ['B', 2, 1]
-
domain
()¶ The module on which the affine Hecke algebra acts.
EXAMPLES:
sage: W = WeylGroup(["B",3]) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: E.domain() Group algebra of Weyl Group of type ['B', 3] (as a matrix group acting on the ambient space) over Multivariate Polynomial Ring in q1, q2 over Rational Field
-
eigenvalue
(mu, l)¶ Return the eigenvalue of
on
computed by applying
on
.
INPUT:
mu
– the indexof an eigenvector, or a tentative eigenvector
l
– the indexof a Cherednik operator in
self.Y_index_set()
This default implementation applies explicitly
to
.
EXAMPLES:
sage: W = WeylGroup(["B",2]) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: w0 = W.long_element() sage: Y = E.Y() sage: alphacheck = Y.keys().simple_roots() sage: E.eigenvalue(w0, alphacheck[1]) q1/(-q2) sage: E.eigenvalue(w0, alphacheck[2]) q1/(-q2) sage: E.eigenvalue(w0, alphacheck[0]) q2^2/q1^2
The following checks that all
are eigenvectors, with eigenvalue given by Lemma 7.5 of [HST2008] (checked for
,
):
sage: Pcheck = Y.keys() sage: Wcheck = Pcheck.weyl_group() sage: P0check = Pcheck.classical() sage: def height(root): ....: return sum(P0check(root).coefficients()) sage: def eigenvalue(w, mu): ....: return (-q2/q1)^height(Wcheck.from_reduced_word(w.reduced_word()).action(mu)) sage: all(E.eigenvalue(w, a) == eigenvalue(w, a) for w in E.keys() for a in Y.keys().simple_roots()) # long time (2.5s) True
-
eigenvalues
(mu)¶ Return the eigenvalues of
on
.
INPUT:
mu
– the indexof an eigenvector or a tentative eigenvector
EXAMPLES:
sage: W = WeylGroup(["B",2]) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: w0 = W.long_element() sage: E.eigenvalues(w0) [q2^2/q1^2, q1/(-q2), q1/(-q2)] sage: w = W.an_element() sage: E.eigenvalues(w) [(-q2)/q1, (-q2^2)/(-q1^2), q1^3/(-q2^3)]
-
hecke_parameters
(i)¶ Return the Hecke parameters for index
i
.EXAMPLES:
sage: W = WeylGroup(["B",3]) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: T = KW.demazure_lusztig_operators(q1, q2, affine=True) sage: E = T.Y_eigenvectors() sage: E.hecke_parameters(1) (q1, q2) sage: E.hecke_parameters(2) (q1, q2) sage: E.hecke_parameters(0) (q1, q2)
-
keys
()¶ The index set for the eigenvectors.
By default, this assumes that the eigenvectors span the full affine Hecke algebra module and that the eigenvectors have the same indexing as the basis of this module.
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: E.keys() Weyl Group of type ['A', 3] (as a matrix group acting on the ambient space)
-
recursion
(mu)¶ Return the indices used in the recursion.
INPUT:
mu
– the indexof an eigenvector
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: w0 = W.long_element() sage: E.recursion(w0) [] sage: w = W.an_element(); w 123 sage: E.recursion(w) [1, 2, 1]
-
seed
(mu)¶ Return the eigenvector for
minuscule.
INPUT:
mu
– an elementof the indexing set
OUTPUT: an element of
T.domain()
This default implementation returns the monomial indexed by
.
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: E = KW.demazure_lusztig_eigenvectors(q1, q2) sage: E.seed(W.long_element()) B[123121]
-
twist
(mu, i)¶ Act by
on
.
By default, this calls the method
apply_simple_reflection
.EXAMPLES:
sage: W = WeylGroup(["B",3]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'] sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: T = KW.demazure_lusztig_operators(q1, q2, affine=True) sage: E = T.Y_eigenvectors() sage: w = W.an_element(); w 123 sage: E.twist(w,1) 1231
-
class
sage.combinat.root_system.hecke_algebra_representation.
HeckeAlgebraRepresentation
(domain, on_basis, cartan_type, q1, q2, q=1, side='right')¶ Bases:
sage.structure.sage_object.SageObject
A representation of an (affine) Hecke algebra given by the action of the
generators
Let
be a family of operators implementing an action of the operators
of the Hecke algebra on some vector space
domain
, given by their action on the basis ofdomain
. This constructs the family of operatorsdescribing the action of all elements of the basis
of the Hecke algebra. This is achieved by linearity on the first argument, and applying recursively the
along a reduced word for
:
INPUT:
domain
– a vector spacef
– a functionf(l,i)
taking a basis elementof
domain
and an index, and returning
cartan_type
– The Cartan type of the Hecke algebraq1,q2
– The eigenvalues of the generatorsof the Hecke algebra
side
– “left” or “right” (default: “right”) whether this is a left or right representation
EXAMPLES:
sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = WeylGroup(["A",3]).algebra(QQ) sage: H = KW.demazure_lusztig_operators(q1,q2); H A representation of the (q1, q2)-Hecke algebra of type ['A', 3, 1] on Group algebra of Weyl Group of type ['A', 3] (as a matrix group acting on the ambient space) over Rational Field
Among other things, it implements the
operators, their inverses and compositions thereof:
sage: H.Tw((1,2)) Generic endomorphism of Group algebra of Weyl Group of type ['A', 3] (as a matrix group acting on the ambient space) over Rational Field
and the Cherednik operators
:
sage: H.Y() Lazy family (...)_{i in Coroot lattice of the Root system of type ['A', 3, 1]}
REFERENCES:
[HST2008] (1, 2, 3, 4, 5) F. Hivert, A. Schilling, N. Thiery, Hecke group algebras as quotients of affine Hecke algebras at level 0, Journal of Combinatorial Theory, Series A 116 (2009) 844-863 ( arXiv:0804.3781 [math.RT] ) -
Ti_inverse_on_basis
(x, i)¶ The
operators, on basis elements
INPUT:
x
– the index of a basis elementi
– the index of a generator
EXAMPLES:
sage: W = WeylGroup("A3") sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: rho = KW.demazure_lusztig_operators(q1,q2) sage: w = W.an_element() sage: rho.Ti_inverse_on_basis(w, 1) -1/q2*B[1231] + ((q1+q2)/(q1*q2))*B[123]
-
Ti_on_basis
(x, i)¶ The
operators, on basis elements.
INPUT:
x
– the index of a basis elementi
– the index of a generator
EXAMPLES:
sage: W = WeylGroup("A3") sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: rho = KW.demazure_lusztig_operators(q1,q2) sage: w = W.an_element() sage: rho.Ti_on_basis(w,1) q1*B[1231]
-
Tw
(word, signs=None, scalar=None)¶ Return
.
INPUT:
word
– a wordfor some element
of the Weyl group. See
straighten_word()
for how this word can be specified.signs
– a listof the same length as
word
withor
None
for(default:
None
)scalar
– an elementof the base ring or
None
for(default:
None
)
OUTPUT:
a module morphism implementing
in left action notation; that is
is applied first, then
, etc.
More generally, if
scalar
orsigns
is specified, the morphism implementsEXAMPLES:
sage: W = WeylGroup("A3") sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: x = KW.an_element(); x 2*B[12321] + 3*B[1231] + B[123] + B[] sage: T = KW.demazure_lusztig_operators(q1,q2) sage: T12 = T.Tw( (1,2) ) sage: T12(KW.one()) q1^2*B[12]
This is
:
sage: T[2](T[1](KW.one())) q1^2*B[12] sage: T[1](T[2](KW.one())) q1^2*B[21] sage: T12(x) == T[2](T[1](x)) True
Now with signs and scalar coefficient we construct
:
sage: phi = T.Tw((1,2), (-1,1), 3) sage: phi(KW.one()) ((-3*q1)/q2)*B[12] + ((3*q1+3*q2)/q2)*B[2] sage: phi(T[1](x)) == 3*T[2](x) True
For debugging purposes, one can recover the input data:
sage: phi.word (1, 2) sage: phi.signs (-1, 1) sage: phi.scalar 3
-
Tw_inverse
(word)¶ Return
.
This is essentially a shorthand for
Tw()
with all minus signs.Todo
Add an example where
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: W.element_class._repr_ = lambda x: "".join(str(i) for i in x.reduced_word()) sage: KW = W.algebra(QQ) sage: rho = KW.demazure_lusztig_operators(1, -1) sage: x = KW.monomial(W.an_element()); x B[123] sage: word = [1,2] sage: rho.Tw(word)(x) B[12312] sage: rho.Tw_inverse(word)(x) B[12321] sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: rho = KW.demazure_lusztig_operators(q1, q2) sage: x = KW.monomial(W.an_element()); x B[123] sage: rho.Tw_inverse(word)(x) 1/q2^2*B[12321] + ((-q1-q2)/(q1*q2^2))*B[1231] + ((-q1-q2)/(q1*q2^2))*B[1232] + ((q1^2+2*q1*q2+q2^2)/(q1^2*q2^2))*B[123] sage: rho.Tw(word)(_) B[123]
-
Y
(base_ring=Integer Ring)¶ Return the Cherednik operators
for this representation of an affine Hecke algebra.
INPUT:
self
– a representation of an affine Hecke algebrabase_ring
– the base ring of the coroot lattice
This is a family of operators indexed by the coroot lattice for this Cartan type. In practice this is currently indexed instead by the affine coroot lattice, even if this indexing is not one to one, in order to allow for
.
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: rho = KW.demazure_lusztig_operators(q2, q1) sage: Y = rho.Y(); Y Lazy family (...(i))_{i in Coroot lattice of the Root system of type ['A', 3, 1]}
-
Y_eigenvectors
()¶ Return the family of eigenvectors for the Cherednik operators
of this representation of an affine Hecke algebra.
INPUT:
self
– a representation of an affine Hecke algebrabase_ring
– the base ring of the coroot lattice
EXAMPLES:
sage: W = WeylGroup(["B",2]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: rho = KW.demazure_lusztig_operators(q1, q2, affine=True) sage: E = rho.Y_eigenvectors() sage: E.keys() Weyl Group of type ['B', 2] (as a matrix group acting on the ambient space) sage: w0 = W.long_element()
To set the recurrence up properly, one often needs to customize the
CherednikOperatorsEigenvectors.affine_lift()
andCherednikOperatorsEigenvectors.affine_retract()
methods. This would usually be done by subclassingCherednikOperatorsEigenvectors
; here we just override the methods directly.In this particular case, we multiply by
to take into account that
is the seed for the recursion:
sage: E.affine_lift = w0._mul_ sage: E.affine_retract = w0._mul_ sage: E[w0] B[2121] sage: E.eigenvalues(E[w0]) [q2^2/q1^2, q1/(-q2), q1/(-q2)]
This step is taken care of automatically if one instead calls the specialization
sage.coxeter_groups.CoxeterGroups.Algebras.demazure_lusztig_eigenvectors()
.Now we can compute all eigenvectors:
sage: [E[w] for w in W] [B[2121] - B[121] - B[212] + B[12] + B[21] - B[1] - B[2] + B[], -B[2121] + B[212], (q2/(q1-q2))*B[2121] + (q2/(-q1+q2))*B[121] + (q2/(-q1+q2))*B[212] - B[12] + ((-q2)/(-q1+q2))*B[21] + B[2], ((-q2^2)/(-q1^2+q1*q2-q2^2))*B[2121] - B[121] + (q2^2/(-q1^2+q1*q2-q2^2))*B[212] + B[21], ((q1^2+q2^2)/(-q1^2+q1*q2-q2^2))*B[2121] + ((-q1^2-q2^2)/(-q1^2+q1*q2-q2^2))*B[121] + ((-q2^2)/(-q1^2+q1*q2-q2^2))*B[212] + (q2^2/(-q1^2+q1*q2-q2^2))*B[12] - B[21] + B[1], B[2121], (q2/(-q1+q2))*B[2121] + ((-q2)/(-q1+q2))*B[121] - B[212] + B[12], -B[2121] + B[121]]
-
Y_lambdacheck
(lambdacheck)¶ Return the Cherednik operators
for this representation of an affine Hecke algebra.
INPUT:
lambdacheck
– an element of the coroot lattice for this cartan type
EXAMPLES:
sage: W = WeylGroup(["B",2]) sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K)
We take
and
as eigenvalues to match with the notations of [HST2008]
sage: rho = KW.demazure_lusztig_operators(q2, q1) sage: L = rho.Y().keys() sage: alpha = L.simple_roots() sage: Y0 = rho.Y_lambdacheck(alpha[0]) sage: Y1 = rho.Y_lambdacheck(alpha[1]) sage: Y2 = rho.Y_lambdacheck(alpha[2]) sage: x = KW.monomial(W.an_element()); x B[12] sage: Y1(x) ((-q1^2-2*q1*q2-q2^2)/(-q2^2))*B[2121] + ((q1^3+q1^2*q2+q1*q2^2+q2^3)/(-q1*q2^2))*B[121] + ((q1^2+q1*q2)/(-q2^2))*B[212] + ((-q1^2)/(-q2^2))*B[12] sage: Y2(x) ((-q1^4-q1^3*q2-q1*q2^3-q2^4)/(-q1^3*q2))*B[2121] + ((q1^3+q1^2*q2+q1*q2^2+q2^3)/(-q1^2*q2))*B[121] + (q2^3/(-q1^3))*B[12] sage: Y1(Y2(x)) ((q1*q2+q2^2)/q1^2)*B[212] + ((-q2)/q1)*B[12] sage: Y2(Y1(x)) ((q1*q2+q2^2)/q1^2)*B[212] + ((-q2)/q1)*B[12]
The
operators commute:
sage: Y0(Y1(x)) - Y1(Y0(x)) 0 sage: Y2(Y1(x)) - Y1(Y2(x)) 0
In the classical root lattice,
:
sage: Y0(Y1(Y2(x))) B[12]
Lemma 7.2 of [HST2008]:
sage: w0 = KW.monomial(W.long_element()) sage: rho.Tw(0)(w0) q2*B[1] sage: rho.Tw_inverse(1)(w0) 1/q2*B[212] sage: rho.Tw_inverse(2)(w0) 1/q2*B[121]
Lemma 7.5 of [HST2008]:
sage: Y0(w0) q1^2/q2^2*B[2121] sage: Y1(w0) (q2/(-q1))*B[2121] sage: Y2(w0) (q2/(-q1))*B[2121]
Todo
Add more tests
Add tests in type BC affine where the null coroot
can have non trivial coefficient in term of
See also
- [HST2008] for the formula in terms of
-
cartan_type
()¶ Return the Cartan type of
self
.EXAMPLES:
sage: from sage.combinat.root_system.hecke_algebra_representation import HeckeAlgebraRepresentation sage: KW = SymmetricGroup(3).algebra(QQ) sage: action = lambda x,i: KW.monomial(x.apply_simple_reflection(i, side="right")) sage: H = HeckeAlgebraRepresentation(KW, action, CartanType(["A",2]), 1, -1) sage: H.cartan_type() ['A', 2] sage: H = WeylGroup(["A",3]).algebra(QQ).demazure_lusztig_operators(-1,1) sage: H.cartan_type() ['A', 3, 1]
-
domain
()¶ Return the domain of
self
.EXAMPLES:
sage: H = WeylGroup(["A",3]).algebra(QQ).demazure_lusztig_operators(-1,1) sage: H.domain() Group algebra of Weyl Group of type ['A', 3] (as a matrix group acting on the ambient space) over Rational Field
-
on_basis
(x, word, signs=None, scalar=None)¶ Action of product of
and
on
x
.INPUT:
x
– the index of a basis elementword
– word of indices of generatorssigns
– (default: None) sequence of signs of same length asword
; determines which operators are supposed to be taken as inverses.scalar
– (default: None) scalar to multiply the answer by
EXAMPLES:
sage: from sage.combinat.root_system.hecke_algebra_representation import HeckeAlgebraRepresentation sage: W = SymmetricGroup(3) sage: domain = W.algebra(QQ) sage: action = lambda x,i: domain.monomial(x.apply_simple_reflection(i, side="right")) sage: rho = HeckeAlgebraRepresentation(domain, action, CartanType(["A",2]), 1, -1) sage: rho.on_basis(W.one(), (1,2,1)) (1,3) sage: word = (1,2) sage: u = W.from_reduced_word(word) sage: for w in W: assert rho.on_basis(w, word) == domain.monomial(w*u)
The next example tests the signs:
sage: W = WeylGroup("A3") sage: W.element_class._repr_=lambda x: "".join(str(i) for i in x.reduced_word()) sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = W.algebra(K) sage: rho = KW.demazure_lusztig_operators(q1,q2) sage: w = W.an_element(); w 123 sage: rho.on_basis(w, (1,), signs=(-1,)) -1/q2*B[1231] + ((q1+q2)/(q1*q2))*B[123] sage: rho.on_basis(w, (1,), signs=( 1,)) q1*B[1231] sage: rho.on_basis(w, (1,1), signs=(1,-1)) B[123] sage: rho.on_basis(w, (1,1), signs=(-1,1)) B[123]
-
parameters
(i)¶ Return
such that
.
EXAMPLES:
sage: K = QQ['q1,q2'].fraction_field() sage: q1, q2 = K.gens() sage: KW = WeylGroup(["A",3]).algebra(QQ) sage: H = KW.demazure_lusztig_operators(q1,q2) sage: H.parameters(1) (q1, q2) sage: H = KW.demazure_lusztig_operators(1,-1) sage: H.parameters(1) (1, -1)
Todo
At this point, this method is constant. It’s meant as a starting point for implementing parameters depending on the node
of the Dynkin diagram.
-
straighten_word
(word)¶ Return a tuple of indices of generators after some straightening.
INPUT:
word
– a list/tuple of indices of generators, the index of a generator, or an object with a reduced word method
OUTPUT: a tuple of indices of generators
EXAMPLES:
sage: W = WeylGroup(["A",3]) sage: H = W.algebra(QQ).demazure_lusztig_operators(-1,1) sage: H.straighten_word(1) (1,) sage: H.straighten_word((2,1)) (2, 1) sage: H.straighten_word([2,1]) (2, 1) sage: H.straighten_word(W.an_element()) (1, 2, 3)