Bases: sage.categories.algebra_functor.AlgebrasCategory
The category of group algebras of root lattice realizations.
This includes typically weight rings (group algebras of weight lattices).
TESTS:
sage: for ct in CartanType.samples(crystallographic=True): # long time
....: TestSuite(RootSystem(ct).root_lattice().algebra(QQ)).run()
Implements the action of w on self.
INPUT:
EXAMPLES:
sage: L = RootSystem(["A",3]).ambient_space()
sage: W = L.weyl_group()
sage: M = L.algebra(QQ['q','t'])
sage: m = M.an_element(); m # TODO: investigate why we don't get something more interesting
B[(2, 2, 3, 0)]
sage: m = (m+1)^2; m
B[(0, 0, 0, 0)] + 2*B[(2, 2, 3, 0)] + B[(4, 4, 6, 0)]
sage: w = W.an_element(); w.reduced_word()
[1, 2, 3]
sage: m.acted_upon(w)
B[(0, 0, 0, 0)] + 2*B[(0, 2, 2, 3)] + B[(0, 4, 4, 6)]
Expand self into variables in the alphabet.
INPUT:
EXAMPLES:
sage: L = RootSystem(["A",2]).ambient_lattice()
sage: KL = L.algebra(QQ)
sage: p = KL.an_element() + KL.sum_of_monomials(L.some_elements()); p
B[(1, 0, 0)] + B[(1, -1, 0)] + B[(1, 1, 0)] + 2*B[(2, 2, 3)] + B[(0, 1, -1)]
sage: F = LaurentPolynomialRing(QQ, 'x,y,z')
sage: p.expand(F.gens())
2*x^2*y^2*z^3 + x*y + x + y*z^-1 + x*y^-1
TESTS:
sage: type(p.expand(F.gens()))
<type 'sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair'>
sage: p = KL.zero()
sage: p.expand(F.gens())
0
sage: type(p.expand(F.gens()))
<type 'sage.rings.polynomial.laurent_polynomial.LaurentPolynomial_mpair'>
Return the operator acting on the basis.
This implements the formula for in Section 6.12 of [Haiman06].
REFERENCES:
[Haiman06] | (1, 2)
|
Warning
The current implementation probably returns just nonsense, if the convention is not “dominant”.
EXAMPLES:
sage: K = QQ['q1,q2'].fraction_field()
sage: q1,q2 = K.gens()
sage: L = RootSystem(["A",1,1]).ambient_space()
sage: L0 = L.classical()
sage: KL = L.algebra(K)
sage: some_weights = L.fundamental_weights()
sage: f = KL.T0_check_on_basis(q1,q2, convention="dominant")
sage: f(L0.zero())
(q1+q2)*B[(0, 0)] + q1*B[(1, -1)]
sage: L = RootSystem(["A",3,1]).ambient_space()
sage: L0 = L.classical()
sage: KL = L.algebra(K)
sage: some_weights = L0.fundamental_weights()
sage: f = KL.T0_check_on_basis(q1,q2, convention="dominant")
sage: f(L0.zero()) # not checked
(q1+q2)*B[(0, 0, 0, 0)] + q1^3/q2^2*B[(1, 0, 0, -1)]
The following results have not been checked:
sage: for x in some_weights:
....: print x, ": ", f(x)
(1, 0, 0, 0) : q1*B[(1, 0, 0, 0)]
(1, 1, 0, 0) : q1*B[(1, 1, 0, 0)]
(1, 1, 1, 0) : q1*B[(1, 1, 1, 0)]
Some examples for type dual:
sage: L = RootSystem("B2~*").ambient_space()
sage: L0 = L.classical()
sage: e = L.basis()
sage: K = QQ['q,u'].fraction_field()
sage: q,u = K.gens()
sage: q1 = u
sage: q2 = -1/u
sage: KL = L.algebra(K)
sage: KL0 = KL.classical()
sage: f = KL.T0_check_on_basis(q1,q2, convention="dominant")
sage: T = KL.twisted_demazure_lusztig_operators(q1,q2, convention="dominant")
Direct calculation:
sage: T.Tw(0)(KL0.monomial(L0([0,0])))
((u^2-1)/u)*B[(0, 0)] + u^3*B[(1, 1)]
sage: KL.T0_check_on_basis(q1,q2, convention="dominant")(L0([0,0]))
((u^2-1)/u)*B[(0, 0)] + u^3*B[(1, 1)]
Step by step calculation, comparing by hand with Mark Shimozono:
sage: res = T.Tw(2)(KL0.monomial(L0([0,0]))); res
u*B[(0, 0)]
sage: res = res * KL0.monomial(L0([-1,1])); res
u*B[(-1, 1)]
sage: res = T.Tw_inverse(1)(res); res
(u^2-1)*B[(0, 0)] + u^2*B[(1, -1)]
sage: res = T.Tw_inverse(2)(res); res
((u^2-1)/u)*B[(0, 0)] + u^3*B[(1, 1)]
Return the Cartan type of self.
EXAMPLES:
sage: A = RootSystem(["A",2,1]).ambient_space().algebra(QQ)
sage: A.cartan_type()
['A', 2, 1]
sage: A = RootSystem(["B",2]).weight_space().algebra(QQ)
sage: A.cartan_type()
['B', 2]
Return the group algebra of the corresponding classical lattice.
EXAMPLES:
sage: KL = RootSystem(["A",2,1]).ambient_space().algebra(QQ)
sage: KL.classical()
Group algebra of the Ambient space of the Root system of type ['A', 2] over Rational Field
Return the result of applying the -th Demazure-Lusztig operator on weight.
INPUT:
See demazure_lusztig_operators() for the details.
EXAMPLES:
sage: L = RootSystem(["A",1]).ambient_space()
sage: K = QQ['q1,q2']
sage: q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: KL.demazure_lusztig_operator_on_basis(L((2,2)), 1, q1, q2)
q1*B[(2, 2)]
sage: KL.demazure_lusztig_operator_on_basis(L((3,0)), 1, q1, q2)
(q1+q2)*B[(1, 2)] + (q1+q2)*B[(2, 1)] + (q1+q2)*B[(3, 0)] + q1*B[(0, 3)]
sage: KL.demazure_lusztig_operator_on_basis(L((0,3)), 1, q1, q2)
(-q1-q2)*B[(1, 2)] + (-q1-q2)*B[(2, 1)] + (-q2)*B[(3, 0)]
At and
we recover the action of the isobaric divided differences
:
sage: KL.demazure_lusztig_operator_on_basis(L((2,2)), 1, 1, 0)
B[(2, 2)]
sage: KL.demazure_lusztig_operator_on_basis(L((3,0)), 1, 1, 0)
B[(1, 2)] + B[(2, 1)] + B[(3, 0)] + B[(0, 3)]
sage: KL.demazure_lusztig_operator_on_basis(L((0,3)), 1, 1, 0)
-B[(1, 2)] - B[(2, 1)]
Or for bar=True:
sage: KL.demazure_lusztig_operator_on_basis(L((2,2)), 1, 1, 0, convention="bar")
0
sage: KL.demazure_lusztig_operator_on_basis(L((3,0)), 1, 1, 0, convention="bar")
-B[(1, 2)] - B[(2, 1)] - B[(0, 3)]
sage: KL.demazure_lusztig_operator_on_basis(L((0,3)), 1, 1, 0, convention="bar")
B[(1, 2)] + B[(2, 1)] + B[(0, 3)]
At and
we recover the action of the simple reflection
:
sage: KL.demazure_lusztig_operator_on_basis(L((2,2)), 1, 1, -1)
B[(2, 2)]
sage: KL.demazure_lusztig_operator_on_basis(L((3,0)), 1, 1, -1)
B[(0, 3)]
sage: KL.demazure_lusztig_operator_on_basis(L((0,3)), 1, 1, -1)
B[(3, 0)]
Return the result of applying the -th Demazure-Lusztig operator on the classical weight weight embedded at level 0.
INPUT:
See demazure_lusztig_operators() for the details.
Todo
EXAMPLES:
sage: L = RootSystem(["A",1,1]).ambient_space()
sage: L0 = L.classical()
sage: K = QQ['q,q1,q2']
sage: q, q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: KL0 = L0.algebra(K)
These operators coincide with the usual Demazure-Lusztig operators:
sage: KL.demazure_lusztig_operator_on_classical_on_basis(L0((2,2)), 1, q, q1, q2)
q1*B[(2, 2)]
sage: KL0.demazure_lusztig_operator_on_basis(L0((2,2)), 1, q1, q2)
q1*B[(2, 2)]
sage: KL.demazure_lusztig_operator_on_classical_on_basis(L0((3,0)), 1, q, q1, q2)
(q1+q2)*B[(1, 2)] + (q1+q2)*B[(2, 1)] + (q1+q2)*B[(3, 0)] + q1*B[(0, 3)]
sage: KL0.demazure_lusztig_operator_on_basis(L0((3,0)), 1, q1, q2)
(q1+q2)*B[(1, 2)] + (q1+q2)*B[(2, 1)] + (q1+q2)*B[(3, 0)] + q1*B[(0, 3)]
except that we now have an action of , which introduces some
s:
sage: KL.demazure_lusztig_operator_on_classical_on_basis(L0((2,2)), 0, q, q1, q2)
q1*B[(2, 2)]
sage: KL.demazure_lusztig_operator_on_classical_on_basis(L0((3,0)), 0, q, q1, q2)
(-q^2*q1-q^2*q2)*B[(1, 2)] + (-q*q1-q*q2)*B[(2, 1)] + (-q^3*q2)*B[(0, 3)]
Return the Demazure-Lusztig operators acting on self.
INPUT:
If is the parent weight ring, the Demazure-Lusztig
operator
is the linear map
obtained
by interpolating between the isobaric divided difference
operator
(see isobaric_divided_difference_on_basis())
and the simple reflection
.
The Demazure-Lusztig operators give the usual
representation of the operator of the (affine) Hecke
algebra with eigenvalues
and
associated to the
Weyl group.
Several variants are available to match with various conventions used in the literature:
The names dominant and antidominant for the conventions were chosen with regards to
the nonsymmetric Macdonald polynomials. The operators for the Macdonald polynomials
in the “dominant” convention satisfy
for
dominant.
This is also the convention used in [Haiman06]. For the “antidominant” convention,
with
antidominant.
REFERENCES:
[Lusztig1985] | G. Lusztig, Equivariant K-theory and representations of Hecke algebras, Proc. Amer. Math. Soc. 94 (1985), no. 2, 337-342. |
[Cherednik1995] | I. Cherednik, Nonsymmetric Macdonald polynomials. IMRN 10, 483-515 (1995). |
EXAMPLES:
sage: L = RootSystem(["A",1]).ambient_space()
sage: K = QQ['q1,q2'].fraction_field()
sage: q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: T = KL.demazure_lusztig_operators(q1, q2)
sage: Tbar = KL.demazure_lusztig_operators(q1, q2, convention="bar")
sage: Tdominant = KL.demazure_lusztig_operators(q1, q2, convention="dominant")
sage: x = KL.monomial(L((3,0)))
sage: T[1](x)
(q1+q2)*B[(1, 2)] + (q1+q2)*B[(2, 1)] + (q1+q2)*B[(3, 0)] + q1*B[(0, 3)]
sage: Tbar[1](x)
(-q1-q2)*B[(1, 2)] + (-q1-q2)*B[(2, 1)] + (-q1-2*q2)*B[(0, 3)]
sage: Tbar[1](x) + T[1](x)
(q1+q2)*B[(3, 0)] + (-2*q2)*B[(0, 3)]
sage: Tdominant[1](x)
(-q1-q2)*B[(1, 2)] + (-q1-q2)*B[(2, 1)] + (-q2)*B[(0, 3)]
sage: Tdominant.Tw_inverse(1)(KL.monomial(-L.simple_root(1)))
((-q1-q2)/(q1*q2))*B[(0, 0)] - 1/q2*B[(1, -1)]
We repeat similar computation in the affine setting:
sage: L = RootSystem(["A",2,1]).ambient_space()
sage: K = QQ['q1,q2'].fraction_field()
sage: q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: T = KL.demazure_lusztig_operators(q1, q2)
sage: Tbar = KL.demazure_lusztig_operators(q1, q2, convention="bar")
sage: Tdominant = KL.demazure_lusztig_operators(q1, q2, convention="dominant")
sage: e = L.basis()
sage: x = KL.monomial(3*e[0])
sage: T[1](x)
(q1+q2)*B[e[0] + 2*e[1]] + (q1+q2)*B[2*e[0] + e[1]] + (q1+q2)*B[3*e[0]] + q1*B[3*e[1]]
sage: Tbar[1](x)
(-q1-q2)*B[e[0] + 2*e[1]] + (-q1-q2)*B[2*e[0] + e[1]] + (-q1-2*q2)*B[3*e[1]]
sage: Tbar[1](x) + T[1](x)
(q1+q2)*B[3*e[0]] + (-2*q2)*B[3*e[1]]
sage: Tdominant[1](x)
(-q1-q2)*B[e[0] + 2*e[1]] + (-q1-q2)*B[2*e[0] + e[1]] + (-q2)*B[3*e[1]]
sage: Tdominant.Tw_inverse(1)(KL.monomial(-L.simple_root(1)))
((-q1-q2)/(q1*q2))*B[0] - 1/q2*B[e[0] - e[1]]
One can obtain iterated operators by passing a reduced word or an element of the Weyl group:
sage: T[1,2](x)
(q1^2+2*q1*q2+q2^2)*B[e[0] + e[1] + e[2]] +
(q1^2+2*q1*q2+q2^2)*B[e[0] + 2*e[1]] +
(q1^2+q1*q2)*B[e[0] + 2*e[2]] + (q1^2+2*q1*q2+q2^2)*B[2*e[0] + e[1]] +
(q1^2+q1*q2)*B[2*e[0] + e[2]] + (q1^2+q1*q2)*B[3*e[0]] +
(q1^2+q1*q2)*B[e[1] + 2*e[2]] + (q1^2+q1*q2)*B[2*e[1] + e[2]] +
(q1^2+q1*q2)*B[3*e[1]] + q1^2*B[3*e[2]]
and use that to check, for example, the braid relations:
sage: T[1,2,1](x) - T[2,1,2](x)
0
The operators satisfy the relations of the affine Hecke
algebra with parameters ,
:
sage: T._test_relations()
sage: Tdominant._test_relations()
sage: Tbar._test_relations() #-q2,q1+2*q2 # todo: not implemented: set the appropriate eigenvalues!
And the are basically the inverses of the
s:
sage: Tinv = KL.demazure_lusztig_operators(2/q1+1/q2,-1/q1,convention="bar")
sage: [Tinv[1](T[1](x))-x for x in KL.some_elements()]
[0, 0, 0, 0, 0, 0, 0]
We check that is an eigenvector for
the
s in affine type:
sage: K = QQ['q,q1,q2'].fraction_field()
sage: q,q1,q2=K.gens()
sage: L = RootSystem(["A",2,1]).ambient_space()
sage: L0 = L.classical()
sage: Lambda = L.fundamental_weights()
sage: alphacheck = L0.simple_coroots()
sage: KL = L.algebra(K)
sage: T = KL.demazure_lusztig_operators(q1, q2, convention="dominant")
sage: Y = T.Y()
sage: alphacheck = Y.keys().alpha() # alpha of coroot lattice is alphacheck
sage: alphacheck
Finite family {0: alphacheck[0], 1: alphacheck[1], 2: alphacheck[2]}
sage: x = KL.monomial(Lambda[1]-Lambda[0]); x
B[e[0]]
In fact it is not exactly an eigenvector, but the extra
‘delta` term is to be interpreted as a parameter:
sage: Y[alphacheck[0]](KL.one())
q2^2/q1^2*B[0]
sage: Y[alphacheck[1]](x)
((-q2^2)/(-q1^2))*B[e[0] - e['delta']]
sage: Y[alphacheck[2]](x)
(q1/(-q2))*B[e[0]]
sage: KL.q_project(Y[alphacheck[1]](x),q)
((-q2^2)/(-q*q1^2))*B[(1, 0, 0)]
sage: KL.q_project(x, q)
B[(1, 0, 0)]
sage: KL.q_project(Y[alphacheck[0]](x),q)
((-q*q1)/q2)*B[(1, 0, 0)]
sage: KL.q_project(Y[alphacheck[1]](x),q)
((-q2^2)/(-q*q1^2))*B[(1, 0, 0)]
sage: KL.q_project(Y[alphacheck[2]](x),q)
(q1/(-q2))*B[(1, 0, 0)]
We now check systematically that the Demazure-Lusztig operators satisfy the relations of the Iwahori-Hecke algebra:
sage: K = QQ['q1,q2']
sage: q1, q2 = K.gens()
sage: for cartan_type in CartanType.samples(crystallographic=True): # long time 12s
....: L = RootSystem(cartan_type).root_lattice()
....: KL = L.algebra(K)
....: T = KL.demazure_lusztig_operators(q1,q2)
....: T._test_relations()
sage: for cartan_type in CartanType.samples(crystallographic=True): # long time 12s
....: L = RootSystem(cartan_type).weight_lattice()
....: KL = L.algebra(K)
....: T = KL.demazure_lusztig_operators(q1,q2)
....: T._test_relations()
Recall that the Demazure-Lusztig operators are only defined when all monomials belong to the weight lattice. Thus, in the group algebra of the ambient space, we need to specify explicitly the elements on which to run the tests:
sage: for cartan_type in CartanType.samples(crystallographic=True): # long time 12s
....: L = RootSystem(cartan_type).ambient_space()
....: KL = L.algebra(K)
....: weight_lattice = RootSystem(cartan_type).weight_lattice(extended=L.is_extended())
....: elements = [ KL.monomial(L(weight)) for weight in weight_lattice.some_elements() ]
....: T = KL.demazure_lusztig_operators(q1,q2)
....: T._test_relations(elements=elements)
Return the Demazure-Lusztig operators acting at level 1 on self.classical().
INPUT:
Let be the group algebra of an affine weight lattice
realization
. The Demazure-Lusztig operators for
act on the group algebra of the corresponding classical
weight lattice by embedding it at level 1, and projecting
back.
See also
EXAMPLES:
sage: L = RootSystem(["A",1,1]).ambient_space()
sage: K = QQ['q,q1,q2'].fraction_field()
sage: q, q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: KL0 = KL.classical()
sage: L0 = KL0.basis().keys()
sage: T = KL.demazure_lusztig_operators_on_classical(q, q1, q2)
sage: x = KL0.monomial(L0((3,0))); x
B[(3, 0)]
For we recover the usual Demazure-Lusztig operators:
sage: T[1](x)
(q1+q2)*B[(1, 2)] + (q1+q2)*B[(2, 1)] + (q1+q2)*B[(3, 0)] + q1*B[(0, 3)]
For , we can note that, in the projection,
is mapped to
:
sage: T[0](x)
(-q^2*q1-q^2*q2)*B[(1, 2)] + (-q*q1-q*q2)*B[(2, 1)] + (-q^3*q2)*B[(0, 3)]
Note that there is no translation part, and in particular
1 is an eigenvector for all ‘s:
sage: T[0](KL0.one())
q1*B[(0, 0)]
sage: T[1](KL0.one())
q1*B[(0, 0)]
sage: Y = T.Y()
sage: alphacheck=Y.keys().simple_roots()
sage: Y[alphacheck[0]](KL0.one())
((-q2)/(q*q1))*B[(0, 0)]
Matching with Ion Bogdan’s hand calculations from 3/15/2013:
sage: L = RootSystem(["A",1,1]).weight_space(extended=True)
sage: K = QQ['q,u'].fraction_field()
sage: q, u = K.gens()
sage: KL = L.algebra(K)
sage: KL0 = KL.classical()
sage: L0 = KL0.basis().keys()
sage: omega = L0.fundamental_weights()
sage: T = KL.demazure_lusztig_operators_on_classical(q, u, -1/u, convention="dominant")
sage: Y = T.Y()
sage: alphacheck = Y.keys().simple_roots()
sage: Ydelta = Y[Y.keys().null_root()]
sage: Ydelta.word, Ydelta.signs, Ydelta.scalar
((), (), 1/q)
sage: Y1 = Y[alphacheck[1]]
sage: Y1.word, Y1.signs, Y1.scalar # This is T_0 T_1 (T_1 acts first, then T_0); Ion gets T_1 T_0
((1, 0), (1, 1), 1)
sage: Y0 = Y[alphacheck[0]]
sage: Y0.word, Y0.signs, Y0.scalar # This is 1/q T_1^-1 T_0^-1
((0, 1), (-1, -1), 1/q)
Note that the following computations use the “dominant” convention:
sage: T0 = T.Tw(0)
sage: T0(KL0.monomial(omega[1]))
q*u*B[-Lambda[1]] + ((u^2-1)/u)*B[Lambda[1]]
sage: T0(KL0.monomial(2*omega[1]))
((q*u^2-q)/u)*B[0] + q^2*u*B[-2*Lambda[1]] + ((u^2-1)/u)*B[2*Lambda[1]]
sage: T0(KL0.monomial(-omega[1]))
1/(q*u)*B[Lambda[1]]
sage: T0(KL0.monomial(-2*omega[1]))
((-u^2+1)/(q*u))*B[0] + 1/(q^2*u)*B[2*Lambda[1]]
Return the Demazure operators acting on self.
The -th Demazure operator is defined by:
It acts on , for
a weight, by:
This matches with Lascoux’ definition [Lascoux2003] of , and
with the
-th Demazure operator of [Kumar1987], which also works for
general Kac-Moody types.
REFERENCES:
[Kumar1987] | S. Kumar, Demazure character formula in arbitrary Kac-Moody setting, Invent. Math. 89 (1987), no. 2, 395-423. |
EXAMPLES:
We compute some Schur functions, as images of dominant
monomials under the action of the maximal isobaric divided
difference :
sage: L = RootSystem(["A",2]).ambient_lattice()
sage: KL = L.algebra(QQ)
sage: w0 = tuple(L.weyl_group().long_element().reduced_word())
sage: pi = KL.demazure_operators()
sage: pi0 = pi[w0]
sage: pi0(KL.monomial(L((2,1))))
2*B[(1, 1, 1)] + B[(1, 2, 0)] + B[(1, 0, 2)] + B[(2, 1, 0)] + B[(2, 0, 1)] + B[(0, 1, 2)] + B[(0, 2, 1)]
Let us make the result into an actual polynomial:
sage: P = QQ['x,y,z']
sage: pi0(KL.monomial(L((2,1)))).expand(P.gens())
x^2*y + x*y^2 + x^2*z + 2*x*y*z + y^2*z + x*z^2 + y*z^2
This is indeed a Schur function:
sage: s = SymmetricFunctions(QQ).s()
sage: s[2,1].expand(3, P.gens())
x^2*y + x*y^2 + x^2*z + 2*x*y*z + y^2*z + x*z^2 + y*z^2
Let us check this systematically on Schur functions of degree 6:
sage: for p in Partitions(6, max_length=3).list():
....: assert s.monomial(p).expand(3, P.gens()) == pi0(KL.monomial(L(tuple(p)))).expand(P.gens())
We check systematically that these operators satisfy the Iwahori-Hecke algebra relations:
sage: for cartan_type in CartanType.samples(crystallographic=True): # long time 12s
....: L = RootSystem(cartan_type).weight_lattice()
....: KL = L.algebra(QQ)
....: T = KL.demazure_operators()
....: T._test_relations()
sage: L = RootSystem(['A',1,1]).weight_lattice()
sage: KL = L.algebra(QQ)
sage: T = KL.demazure_operators()
sage: T._test_relations()
Warning
The Demazure operators are only defined if all the elements in the support have integral scalar products with the coroots (basically, they are in the weight lattice). Otherwise an error is raised:
sage: L = RootSystem(CartanType(["G",2]).dual()).ambient_space()
sage: KL = L.algebra(QQ)
sage: pi = KL.demazure_operators()
sage: pi[1](KL.monomial(L([0,0,1])))
Traceback (most recent call last):
...
ValueError: the weight does not have an integral scalar product with the coroot
Return the result of applying the -th divided difference on weight.
INPUT:
Todo
type free definition (Viviane’s definition uses that we are in the ambient space)
EXAMPLES:
sage: L = RootSystem(["A",1]).ambient_space()
sage: KL = L.algebra(QQ)
sage: KL.divided_difference_on_basis(L((2,2)), 1) # todo: not implemented
0
sage: KL.divided_difference_on_basis(L((3,0)), 1) # todo: not implemented
B[(2, 0)] + B[(1, 1)] + B[(0, 2)]
sage: KL.divided_difference_on_basis(L((0,3)), 1) # todo: not implemented
-B[(2, 0)] - B[(1, 1)] - B[(0, 2)]
In type and in the ambient lattice, we recover the
usual action of divided differences polynomials:
sage: x,y = QQ['x,y'].gens()
sage: d = lambda p: (p - p(y,x)) / (x-y)
sage: d(x^2*y^2)
0
sage: d(x^3)
x^2 + x*y + y^2
sage: d(y^3)
-x^2 - x*y - y^2
Construct an element of self from a polynomial .
INPUT:
EXAMPLES:
sage: L = RootSystem(["A",2]).ambient_lattice()
sage: KL = L.algebra(QQ)
sage: x,y,z = QQ['x,y,z'].gens()
sage: KL.from_polynomial(x)
B[(1, 0, 0)]
sage: KL.from_polynomial(x^2*y + 2*y - z)
B[(2, 1, 0)] + 2*B[(0, 1, 0)] - B[(0, 0, 1)]
TESTS:
sage: KL.from_polynomial(x).leading_support().parent() is L
True
sage: KL.from_polynomial(x-x)
0
sage: KL.from_polynomial(x-x).parent() is KL
True
Todo
make this work for Laurent polynomials too
Return the result of applying the -th isobaric divided difference on weight.
INPUT:
See also
EXAMPLES:
sage: L = RootSystem(["A",1]).ambient_space()
sage: KL = L.algebra(QQ)
sage: KL.isobaric_divided_difference_on_basis(L((2,2)), 1)
B[(2, 2)]
sage: KL.isobaric_divided_difference_on_basis(L((3,0)), 1)
B[(1, 2)] + B[(2, 1)] + B[(3, 0)] + B[(0, 3)]
sage: KL.isobaric_divided_difference_on_basis(L((0,3)), 1)
-B[(1, 2)] - B[(2, 1)]
In type and in the ambient lattice, we recover the
usual action of divided differences on polynomials:
sage: x,y = QQ['x,y'].gens()
sage: d = lambda p: (x*p - (x*p)(y,x)) / (x-y)
sage: d(x^2*y^2)
x^2*y^2
sage: d(x^3)
x^3 + x^2*y + x*y^2 + y^3
sage: d(y^3)
-x^2*y - x*y^2
REFERENCES:
[Lascoux2003] | Alain Lascoux, Symmetric functions and combinatorial operators on polynomials, CBMS Regional Conference Series in Mathematics, 99, 2003. |
Implement the -projection morphism from self to the group algebra of the classical space.
INPUT:
This is an algebra morphism mapping to
and
to its classical counterpart for the other elements
of the basis of the realization.
EXAMPLES:
sage: K = QQ['q'].fraction_field()
sage: q = K.gen()
sage: KL = RootSystem(["A",2,1]).ambient_space().algebra(K)
sage: L = KL.basis().keys()
sage: e = L.basis()
sage: x = KL.an_element() + KL.monomial(4*e[1] + 3*e[2] + e['deltacheck'] - 2*e['delta']); x
B[2*e[0] + 2*e[1] + 3*e[2]] + B[4*e[1] + 3*e[2] - 2*e['delta'] + e['deltacheck']]
sage: KL.q_project(x, q)
B[(2, 2, 3)] + 1/q^2*B[(0, 4, 3)]
sage: KL = RootSystem(["BC",3,2]).ambient_space().algebra(K)
sage: L = KL.basis().keys()
sage: e = L.basis()
sage: x = KL.an_element() + KL.monomial(4*e[1] + 3*e[2] + e['deltacheck'] - 2*e['delta']); x
B[2*e[0] + 2*e[1] + 3*e[2]] + B[4*e[1] + 3*e[2] - 2*e['delta'] + e['deltacheck']]
sage: KL.q_project(x, q)
B[(2, 2, 3)] + 1/q^2*B[(0, 4, 3)]
Warning
Recall that the null root, usually denoted ,
is in fact a[0]\delta in Sage’s notation, in order
to avoid half integer coefficients (this only makes a
difference in type BC). Similarly, what’s usually
denoted
is in fact q^a[0] in Sage’s notations,
to avoid manipulating square roots:
sage: KL.q_project(KL.monomial(L.null_root()),q)
q^2*B[(0, 0, 0)]
Return the monomial in the group algebra of the classical lattice.
INPUT:
Here, is the projection of
in the classical
lattice, and
is the coefficient of
in
.
See also
EXAMPLES:
sage: K = QQ['q'].fraction_field()
sage: q = K.gen()
sage: KL = RootSystem(["A",2,1]).ambient_space().algebra(K)
sage: L = KL.basis().keys()
sage: e = L.basis()
sage: KL.q_project_on_basis( 4*e[1] + 3*e[2] + e['deltacheck'] - 2*e['delta'], q)
1/q^2*B[(0, 4, 3)]
Return some elements of the algebra self.
EXAMPLES:
sage: A = RootSystem(["A",2,1]).ambient_space().algebra(QQ)
sage: A.some_elements()
[B[2*e[0] + 2*e[1] + 3*e[2]],
B[-e[0] + e[2] + e['delta']],
B[e[0] - e[1]],
B[e[1] - e[2]],
B[e['deltacheck']],
B[e[0] + e['deltacheck']],
B[e[0] + e[1] + e['deltacheck']]]
sage: A = RootSystem(["B",2]).weight_space().algebra(QQ)
sage: A.some_elements()
[B[2*Lambda[1] + 2*Lambda[2]],
B[2*Lambda[1] - 2*Lambda[2]],
B[-Lambda[1] + 2*Lambda[2]],
B[Lambda[1]],
B[Lambda[2]]]
Return the twisted Demazure-Lusztig operator acting on the basis.
INPUT:
See also
EXAMPLES:
sage: L = RootSystem(["A",3,1]).ambient_space()
sage: e = L.basis()
sage: K = QQ['q1,q2'].fraction_field()
sage: q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: Lambda = L.classical().fundamental_weights()
sage: KL.twisted_demazure_lusztig_operator_on_basis(Lambda[1]+2*Lambda[2], 1, q1, q2, convention="dominant")
(-q2)*B[(2, 3, 0, 0)]
sage: KL.twisted_demazure_lusztig_operator_on_basis(Lambda[1]+2*Lambda[2], 2, q1, q2, convention="dominant")
(-q1-q2)*B[(3, 1, 1, 0)] + (-q2)*B[(3, 0, 2, 0)]
sage: KL.twisted_demazure_lusztig_operator_on_basis(Lambda[1]+2*Lambda[2], 3, q1, q2, convention="dominant")
q1*B[(3, 2, 0, 0)]
sage: KL.twisted_demazure_lusztig_operator_on_basis(Lambda[1]+2*Lambda[2], 0, q1, q2, convention="dominant")
((q1*q2+q2^2)/q1)*B[(1, 2, 1, 1)] + ((q1*q2+q2^2)/q1)*B[(1, 2, 2, 0)] + q2^2/q1*B[(1, 2, 0, 2)]
+ ((q1^2+2*q1*q2+q2^2)/q1)*B[(2, 1, 1, 1)] + ((q1^2+2*q1*q2+q2^2)/q1)*B[(2, 1, 2, 0)]
+ ((q1*q2+q2^2)/q1)*B[(2, 1, 0, 2)] + ((q1^2+2*q1*q2+q2^2)/q1)*B[(2, 2, 1, 0)] + ((q1*q2+q2^2)/q1)*B[(2, 2, 0, 1)]
Return the twisted Demazure-Lusztig operators acting on self.
INPUT:
Warning
For , these operators are the usual
Demazure-Lusztig operators. On the other hand, the
operator
is twisted:
sage: L = RootSystem(["A",3,1]).ambient_space()
sage: e = L.basis()
sage: K = QQ['q1,q2'].fraction_field()
sage: q1, q2 = K.gens()
sage: KL = L.algebra(K)
sage: T = KL.twisted_demazure_lusztig_operators(q1, q2, convention="dominant")
sage: T._test_relations()
TESTS:
The following computations were checked with Mark Shimozono for type :
sage: L = RootSystem(["A",1,1]).ambient_space()
sage: e = L.basis()
sage: K = QQ['q1,q2'].fraction_field()
sage: q1,q2 = K.gens()
sage: KL = L.algebra(K)
sage: T = KL.twisted_demazure_lusztig_operators(q1, q2, convention="dominant")
sage: T._test_relations()
sage: L0 = L.classical()
sage: alpha = L0.simple_roots()
sage: T.Ti_on_basis(L0.zero(), 1)
q1*B[(0, 0)]
sage: T.Ti_inverse_on_basis(L0.zero(), 1)
1/q1*B[(0, 0)]
sage: T.Ti_on_basis(alpha[1], 1)
(-q1-q2)*B[(0, 0)] + (-q2)*B[(-1, 1)]
sage: T.Ti_inverse_on_basis(alpha[1], 1)
((q1+q2)/(q1*q2))*B[(0, 0)] + 1/q1*B[(-1, 1)] + ((q1+q2)/(q1*q2))*B[(1, -1)]
sage: T.Ti_on_basis(L0.zero(), 0)
(q1+q2)*B[(0, 0)] + q1*B[(1, -1)]
The next computations were checked with Mark Shimozono for type :
sage: L = RootSystem(["A",2,1]).ambient_space()
sage: e = L.basis()
sage: K = QQ['u'].fraction_field()
sage: u = K.gen()
sage: KL = L.algebra(K)
sage: T = KL.twisted_demazure_lusztig_operators(u, -~u, convention="dominant")
sage: T._test_relations()
sage: L0 = L.classical()
sage: KL0 = L0.algebra(K)
sage: alpha = L0.simple_roots()
sage: phi = L0.highest_root(); phi
(1, 0, -1)
sage: phi.to_simple_root(reduced_word=True)
(2, (1,))
sage: res = T.Ti_on_basis(L0([1,0,1]), 1); res
1/u*B[(0, 1, 1)]
sage: res = res * KL0.monomial(-alpha[2]); res
1/u*B[(0, 0, 2)]
sage: res = T.Tw_inverse(2)(res); res
((u^2-1)/u^2)*B[(0, 1, 1)] + B[(0, 2, 0)]
sage: res = T.Tw_inverse(1)(res); res
((u^2-1)/u)*B[(1, 1, 0)] + ((u^2-1)/u)*B[(1, 0, 1)] + u*B[(2, 0, 0)]
Todo
Choose a good set of Cartan Type to run on. Rank >4 is
too big. But and
are boring.
We now check systematically that those operators satisfy the relations of the Iwahori-Hecke algebra:
sage: K = QQ['q1,q2'].fraction_field()
sage: q1, q2 = K.gens()
sage: for cartan_type in CartanType.samples(affine=True, crystallographic=True): # long time 12s
....: if cartan_type.rank() > 4: continue
....: if cartan_type.type() == 'BC': continue
....: KL = RootSystem(cartan_type).weight_lattice().algebra(K)
....: T = KL.twisted_demazure_lusztig_operators(q1, q2, convention="dominant")
....: T._test_relations()
Todo
Investigate why currently does not satisfy
the quadratic relation in type
. This should
hopefuly be fixed when
will have a more
uniform implementation:
sage: cartan_type = CartanType(["BC",1,2])
sage: KL = RootSystem(cartan_type).weight_lattice().algebra(K)
sage: T = KL.twisted_demazure_lusztig_operators(q1,q2, convention="dominant")
sage: T._test_relations()
... tester.assert_(Ti(Ti(x,i,-q2),i,-q1).is_zero()) ...
AssertionError: False is not true
Comparison with T0:
sage: L = RootSystem(["A",2,1]).ambient_space()
sage: e = L.basis()
sage: K = QQ['t,q'].fraction_field()
sage: t,q = K.gens()
sage: q1 = t
sage: q2 = -1
sage: KL = L.algebra(K)
sage: L0 = L.classical()
sage: T = KL.demazure_lusztig_operators(q1,q2, convention="dominant")
sage: def T0(*l0): return KL.q_project(T[0].on_basis()(L.embed_at_level(L0(l0), 1)), q)
sage: T0_check_on_basis = KL.T0_check_on_basis(q1, q2, convention="dominant")
sage: def T0c(*l0): return T0_check_on_basis(L0(l0))
sage: T0(0,0,1) # not double checked
((-t+1)/q)*B[(1, 0, 0)] + 1/q^2*B[(2, 0, -1)]
sage: T0c(0,0,1)
(t^2-t)*B[(1, 0, 0)] + (t^2-t)*B[(1, 1, -1)] + t^2*B[(2, 0, -1)] + (t-1)*B[(0, 0, 1)]