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:
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:
Todo
Add tests for the above assumptions, and also that the
classical operators from
and
coincide.
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]}
Lift the index \mu to a space admitting an action of the affine Weyl group.
INPUT:
In this space, one should have first_descent and apply_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
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
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]
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
Return the eigenvalue of on
computed by applying
on
.
INPUT:
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
Return the eigenvalues of on
.
INPUT:
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)]
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)
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)
Return the indices used in the recursion.
INPUT:
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]
Return the eigenvector for minuscule.
INPUT:
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]
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
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 of
domain. This constructs the family of operators
describing 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:
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] ) |
The operators, on basis elements
INPUT:
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]
The operators, on basis elements.
INPUT:
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]
Return .
INPUT:
OUTPUT:
a module morphism implementing
in left action notation; that is is applied first,
then
, etc.
More generally, if scalar or signs is specified, the morphism implements
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: 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
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]
Return the Cherednik operators for this representation of an affine Hecke algebra.
INPUT:
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]}
Return the family of eigenvectors for the Cherednik operators of this representation of an affine Hecke algebra.
INPUT:
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() and CherednikOperatorsEigenvectors.affine_retract() methods. This would usually be done by subclassing CherednikOperatorsEigenvectors; 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]]
Return the Cherednik operators for this representation of an affine Hecke algebra.
INPUT:
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
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]
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
Action of product of and
on x.
INPUT:
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]
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.
Return a tuple of indices of generators after some straightening.
INPUT:
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)