AUTHORS:
Bases: sage.structure.parent.Parent, sage.structure.unique_representation.UniqueRepresentation
Returns the Iwahori-Hecke algebra of the Coxeter group W with the specified parameters.
INPUT:
OPTIONAL ARGUMENTS:
The Iwahori-Hecke algebra [I64] is a deformation of the group algebra of
a Weyl group or, more generally, a Coxeter group. These algebras are
defined by generators and relations and they depend on a deformation
parameter . Taking
, as in the following example, gives a ring
isomorphic to the group algebra of the corresponding Coxeter group.
Let be a Coxeter system and let
be a commutative ring
containing elements
and
. Then the Iwahori-Hecke algebra
of
with parameters
and
is the
unital associative algebra with generators
and
relations:
where the number of terms on either side of the second relations (the braid
relations) is the order of in the Coxeter group
, for
.
Iwahori-Hecke algebras are fundamental in many areas of mathematics, ranging from the representation theory of Lie groups and quantum groups, to knot theory and statistical mechanics. For more information see, for example, [KL79], [HKP], [J87] and Wikipedia article Iwahori-Hecke_algebra.
Bases
A reduced expression for an element is any minimal length
word
, with
. If
is a
reduced expression for
then Matsumoto’s Monoid Lemma implies that
depends on
and not on the choice of
reduced expressions. Moreover,
is a basis for the
Iwahori-Hecke algebra
and
The -basis of
is implemented for any choice of parameters
q_1 and q_2:
sage: R.<u,v> = LaurentPolynomialRing(ZZ,2)
sage: H = IwahoriHeckeAlgebra('A3', u,v)
sage: T = H.T()
sage: T[1]
T[1]
sage: T[1,2,1] + T[2]
T[1,2,1] + T[2]
sage: T[1] * T[1,2,1]
(u+v)*T[1,2,1] + (-u*v)*T[2,1]
sage: T[1]^-1
(-u^-1*v^-1)*T[1] + (v^-1+u^-1)
Working over the Laurent polynomial ring Kazhdan and
Lusztig proved that there exist two distinguished bases
and
of
which are uniquely determined by the properties that they are invariant
under the bar involution on
and have triangular transitions matrices
with polynomial entries of a certain form with the
-basis;
see [KL79] for a precise statement.
It turns out that the Kazhdan-Lusztig bases can be defined (by
specialization) in whenever
is a square in the base ring.
The Kazhdan-Lusztig bases are implemented inside
whenever
has a square root:
sage: H = IwahoriHeckeAlgebra('A3', u^2,-v^2)
sage: T=H.T(); Cp= H.Cp(); C=H.C()
sage: T(Cp[1])
(u^-1*v^-1)*T[1] + (u^-1*v)
sage: T(C[1])
(u^-1*v^-1)*T[1] + (-u*v^-1)
sage: Cp(C[1])
Cp[1] + (-u*v^-1-u^-1*v)
sage: elt = Cp[2]*Cp[3]+C[1]; elt
Cp[2,3] + Cp[1] + (-u*v^-1-u^-1*v)
sage: c = C(elt); c
C[2,3] + C[1] + (u*v^-1+u^-1*v)*C[2] + (u*v^-1+u^-1*v)*C[3] + (u^2*v^-2+2+u^-2*v^2)
sage: t = T(c); t
(u^-2*v^-2)*T[2,3] + (u^-1*v^-1)*T[1] + (u^-2)*T[2] + (u^-2)*T[3] + (-u*v^-1+u^-2*v^2)
sage: Cp(t)
Cp[2,3] + Cp[1] + (-u*v^-1-u^-1*v)
sage: Cp(c)
Cp[2,3] + Cp[1] + (-u*v^-1-u^-1*v)
The conversions to and from the Kazhdan-Lusztig bases are done behind the scenes whenever the Kazhdan-Lusztig bases are well-defined. Once a suitable Iwahori-Hecke algebra is defined they will work without further intervention.
For example, with the “standard parameters”, so that
:
sage: R.<q> = LaurentPolynomialRing(ZZ)
sage: H = IwahoriHeckeAlgebra('A3', q^2)
sage: T=H.T(); Cp=H.Cp(); C=H.C()
sage: C(T[1])
q*C[1] + q^2
sage: elt = Cp(T[1,2,1]); elt
q^3*Cp[1,2,1] - q^2*Cp[1,2] - q^2*Cp[2,1] + q*Cp[1] + q*Cp[2] - 1
sage: C(elt)
q^3*C[1,2,1] + q^4*C[1,2] + q^4*C[2,1] + q^5*C[1] + q^5*C[2] + q^6
With the “normalized presentation”, so that :
sage: R.<q> = LaurentPolynomialRing(ZZ)
sage: H = IwahoriHeckeAlgebra('A3', q, -q^-1)
sage: T=H.T(); Cp=H.Cp(); C=H.C()
sage: C(T[1])
C[1] + q
sage: elt = Cp(T[1,2,1]); elt
Cp[1,2,1] - (q^-1)*Cp[1,2] - (q^-1)*Cp[2,1] + (q^-2)*Cp[1] + (q^-2)*Cp[2] - (q^-3)
sage: C(elt)
C[1,2,1] + q*C[1,2] + q*C[2,1] + q^2*C[1] + q^2*C[2] + q^3
In the group algebra, so that :
sage: H = IwahoriHeckeAlgebra('A3', 1)
sage: T=H.T(); Cp=H.Cp(); C=H.C()
sage: C(T[1])
C[1] + 1
sage: Cp(T[1,2,1])
Cp[1,2,1] - Cp[1,2] - Cp[2,1] + Cp[1] + Cp[2] - 1
sage: C(_)
C[1,2,1] + C[1,2] + C[2,1] + C[1] + C[2] + 1
On the other hand, if the Kazhdan-Lusztig bases are not well-defined (when
is not a square), attempting to use the Kazhdan-Lusztig bases
triggers an error:
sage: R.<q>=LaurentPolynomialRing(ZZ)
sage: H = IwahoriHeckeAlgebra('A3', q)
sage: C=H.C()
Traceback (most recent call last):
...
ValueError: The Kazhdan_Lusztig bases are defined only when -q_1*q_2 is a square
We give an example in affine type:
sage: R.<v> = LaurentPolynomialRing(ZZ)
sage: H = IwahoriHeckeAlgebra(['A',2,1], v^2)
sage: T=H.T(); Cp=H.Cp(); C=H.C()
sage: C(T[1,0,2])
v^3*C[1,0,2] + v^4*C[1,0] + v^4*C[0,2] + v^4*C[1,2]
+ v^5*C[0] + v^5*C[2] + v^5*C[1] + v^6
sage: Cp(T[1,0,2])
v^3*Cp[1,0,2] - v^2*Cp[1,0] - v^2*Cp[0,2] - v^2*Cp[1,2]
+ v*Cp[0] + v*Cp[2] + v*Cp[1] - 1
sage: T(C[1,0,2])
(v^-3)*T[1,0,2] - (v^-1)*T[1,0] - (v^-1)*T[0,2] - (v^-1)*T[1,2]
+ v*T[0] + v*T[2] + v*T[1] - v^3
sage: T(Cp[1,0,2])
(v^-3)*T[1,0,2] + (v^-3)*T[1,0] + (v^-3)*T[0,2] + (v^-3)*T[1,2]
+ (v^-3)*T[0] + (v^-3)*T[2] + (v^-3)*T[1] + (v^-3)
REFERENCES:
[I64] | (1, 2) N. Iwahori, On the structure of a Hecke ring of a Chevalley group over a finite field, J. Fac. Sci. Univ. Tokyo Sect. I, 10 (1964), 215–236 (1964). MathSciNet MR0165016 |
[HKP] | T. J. Haines, R. E. Kottwitz, A. Prasad, Iwahori-Hecke Algebras, J. Ramanujan Math. Soc., 25 (2010), 113–145. Arxiv 0309168v3 MathSciNet MR2642451 |
[J87] | V. Jones, Hecke algebra representations of braid groups and link polynomials. Ann. of Math. (2) 126 (1987), no. 2, 335–388. doi:10.2307/1971403 MathSciNet MR0908150 |
EXAMPLES:
We start by creating a Iwahori-Hecke algebra together with the three bases for these algebras that are currently supported:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: T = H.T()
sage: C = H.C()
sage: Cp = H.Cp()
It is also possible to define these three bases quickly using the inject_shorthands() method.
Next we create our generators for the -basis and do some basic
computations and conversions between the bases:
sage: T1,T2,T3 = T.algebra_generators()
sage: T1 == T[1]
True
sage: T1*T2 == T[1,2]
True
sage: T1 + T2
T[1] + T[2]
sage: T1*T1
-(1-v^2)*T[1] + v^2
sage: (T1 + T2)*T3 + T1*T1 - (v + v^-1)*T2
T[3,1] + T[2,3] - (1-v^2)*T[1] - (v^-1+v)*T[2] + v^2
sage: Cp(T1)
v*Cp[1] - 1
sage: Cp((v^1 - 1)*T1*T2 - T3)
-(v^2-v^3)*Cp[1,2] + (v-v^2)*Cp[1] + (v-v^2)*Cp[2] - v*Cp[3] + v
sage: C(T1)
v*C[1] + v^2
sage: p = C(T2*T3 - v*T1); p
v^2*C[2,3] - v^2*C[1] + v^3*C[2] + v^3*C[3] - (v^3-v^4)
sage: Cp(p)
v^2*Cp[2,3] - v^2*Cp[1] - v*Cp[2] - v*Cp[3] + (1+v)
sage: Cp(T2*T3 - v*T1)
v^2*Cp[2,3] - v^2*Cp[1] - v*Cp[2] - v*Cp[3] + (1+v)
In addition to explicitly creating generators, we have two shortcuts to basis elements. The first is by using elements of the underlying Coxeter group, the other is by using reduced words:
sage: s1,s2,s3 = H.coxeter_group().gens()
sage: T[s1*s2*s1*s3] == T[1,2,1,3]
True
sage: T[1,2,1,3] == T1*T2*T1*T3
True
TESTS:
We check the defining properties of the bases:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: T = H.T()
sage: C = H.C()
sage: Cp = H.Cp()
sage: T(Cp[1])
(v^-1)*T[1] + (v^-1)
sage: T(C[1])
(v^-1)*T[1] - v
sage: C(Cp[1])
C[1] + (v^-1+v)
sage: Cp(C[1])
Cp[1] - (v^-1+v)
sage: all(C[x] == C[x].bar() for x in W) # long time
True
sage: all(Cp[x] == Cp[x].bar() for x in W) # long time
True
sage: all(T(C[x]).bar() == T(C[x]) for x in W) # long time
True
sage: all(T(Cp[x]).bar() == T(Cp[x]) for x in W) # long time
True
sage: KL = KazhdanLusztigPolynomial(W, v)
sage: term = lambda x,y: (-1)^y.length() * v^(-2*y.length()) * KL.P(y, x).substitute(v=v^-2)*T[y]
sage: all(T(C[x]) == (-v)^x.length()*sum(term(x,y) for y in W) for x in W) # long time
True
sage: all(T(Cp[x]) == v^-x.length()*sum(KL.P(y,x).substitute(v=v^2)*T[y] for y in W) for x in W) # long time
True
We check conversion between the bases for type as well as some of
the defining properties:
sage: H = IwahoriHeckeAlgebra(['B',2], v**2)
sage: W = H.coxeter_group()
sage: T = H.T()
sage: C = H.C()
sage: Cp = H.Cp()
sage: all(T[x] == T(C(T[x])) for x in W) # long time
True
sage: all(T[x] == T(Cp(T[x])) for x in W) # long time
True
sage: all(C[x] == C(T(C[x])) for x in W) # long time
True
sage: all(C[x] == C(Cp(C[x])) for x in W) # long time
True
sage: all(Cp[x] == Cp(T(Cp[x])) for x in W) # long time
True
sage: all(Cp[x] == Cp(C(Cp[x])) for x in W) # long time
True
sage: all(T(C[x]).bar() == T(C[x]) for x in W) # long time
True
sage: all(T(Cp[x]).bar() == T(Cp[x]) for x in W) # long time
True
sage: KL = KazhdanLusztigPolynomial(W, v)
sage: term = lambda x,y: (-1)^y.length() * v^(-2*y.length()) * KL.P(y, x).substitute(v=v^-2)*T[y]
sage: all(T(C[x]) == (-v)^x.length()*sum(term(x,y) for y in W) for x in W) # long time
True
sage: all(T(Cp[x]) == v^-x.length()*sum(KL.P(y,x).substitute(v=v^2)*T[y] for y in W) for x in W) # long time
True
Todo
Implement multi-parameter Iwahori-Hecke algebras together with their Kazhdan-Lusztig bases. That is, Iwahori-Hecke algebras with (possibly) different parameters for each conjugacy class of simple reflections in the underlying Coxeter group.
Todo
When given “generic parameters” we should return the generic Iwahori-Hecke algebra with these parameters and allow the user to work inside this algebra rather than doing calculations behind the scenes in a copy of the generic Iwahori-Hecke algebra. The main problem is that it is not clear how to recognise when the parameters are “generic”.
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra._KLHeckeBasis
The Kazhdan-Lusztig -basis of Iwahori-Hecke algebra.
Assuming the standard quadratic relations of , for
every element
in the Coxeter group, there is a unique element
in the Iwahori-Hecke algebra which is uniquely determined
by the two properties:
where is the Bruhat order on the underlying Coxeter group and
are polynomials in
such that
and if
then
.
More generally, if the quadratic relations are of the form
(T_s-q_1)(T_s-q_2)=0` and exists then for a simple
reflection
then the corresponding Kazhdan-Lusztig basis element is:
This is related to the Kazhdan-Lusztig basis by
where
is the
-linear Hecke
involution defined by
and
.
See [KL79] for more details.
EXAMPLES:
sage: R.<v> = LaurentPolynomialRing(QQ)
sage: H = IwahoriHeckeAlgebra('A5', v**2)
sage: W = H.coxeter_group()
sage: s1,s2,s3,s4,s5 = W.simple_reflections()
sage: T = H.T()
sage: C = H.C()
sage: T(s1)**2
-(1-v^2)*T[1] + v^2
sage: T(C(s1))
(v^-1)*T[1] - v
sage: T(C(s1)*C(s2)*C(s1))
(v^-3)*T[1,2,1] - (v^-1)*T[1,2] - (v^-1)*T[2,1] + (v^-1+v)*T[1] + v*T[2] - (v+v^3)
sage: R.<v> = LaurentPolynomialRing(QQ)
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: s1,s2,s3 = W.simple_reflections()
sage: C = H.C()
sage: C(s1*s2*s1)
C[1,2,1]
sage: C(s1)**2
-(v^-1+v)*C[1]
sage: C(s1)*C(s2)*C(s1)
C[1,2,1] + C[1]
TESTS:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: T = H.T()
sage: C = H.C()
sage: Cp = H.Cp()
sage: all(C(T(C[x])) == C[x] for x in W) # long time
True
sage: all(C(Cp(C[x])) == C[x] for x in W) # long time
True
Check the defining property between and
:
sage: T(C[1])
(v^-1)*T[1] - v
sage: -T(Cp[1]).hash_involution()
(v^-1)*T[1] - v
sage: T(Cp[1] + Cp[2]).hash_involution()
-(v^-1)*T[1] - (v^-1)*T[2] + 2*v
sage: -T(C[1] + C[2])
-(v^-1)*T[1] - (v^-1)*T[2] + 2*v
sage: Cp(-C[1].hash_involution())
Cp[1]
sage: Cp(-C[1,2,3].hash_involution())
Cp[1,2,3]
sage: Cp(C[1,2,1,3].hash_involution())
Cp[1,2,3,1]
sage: all(C((-1)**x.length()*Cp[x].hash_involution()) == C[x] for x in W) # long time
True
Return the effect of applying the hash involution to the basis element self[w].
This function is not intended to be called directly. Instead, use hash_involution().
EXAMPLES:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: C=H.C()
sage: s=H.coxeter_group().simple_reflection(1)
sage: C.hash_involution_on_basis(s)
-C[1] - (v^-1+v)
sage: C[s].hash_involution()
-C[1] - (v^-1+v)
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra._KLHeckeBasis
The Kazhdan-Lusztig basis of Iwahori-Hecke algebra.
Assuming the standard quadratic relations of , for
every element
in the Coxeter group, there is a unique element
in the Iwahori-Hecke algebra which is uniquely determined
by the two properties:
where is the Bruhat order on the underlying Coxeter group and
are polynomials in
such that
and if
then
.
More generally, if the quadratic relations are of the form
(T_s-q_1)(T_s-q_2)=0` and exists then for a simple
reflection
then the corresponding Kazhdan-Lusztig basis element is:
See [KL79] for more details.
EXAMPLES:
sage: R = LaurentPolynomialRing(QQ, 'v')
sage: v = R.gen(0)
sage: H = IwahoriHeckeAlgebra('A5', v**2)
sage: W = H.coxeter_group()
sage: s1,s2,s3,s4,s5 = W.simple_reflections()
sage: T = H.T()
sage: Cp = H.Cp()
sage: T(s1)**2
-(1-v^2)*T[1] + v^2
sage: T(Cp(s1))
(v^-1)*T[1] + (v^-1)
sage: T(Cp(s1)*Cp(s2)*Cp(s1))
(v^-3)*T[1,2,1] + (v^-3)*T[1,2] + (v^-3)*T[2,1]
+ (v^-3+v^-1)*T[1] + (v^-3)*T[2] + (v^-3+v^-1)
sage: R = LaurentPolynomialRing(QQ, 'v')
sage: v = R.gen(0)
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: s1,s2,s3 = W.simple_reflections()
sage: Cp = H.Cp()
sage: Cp(s1*s2*s1)
Cp[1,2,1]
sage: Cp(s1)**2
(v^-1+v)*Cp[1]
sage: Cp(s1)*Cp(s2)*Cp(s1)
Cp[1,2,1] + Cp[1]
sage: Cp(s1)*Cp(s2)*Cp(s3)*Cp(s1)*Cp(s2) # long time
Cp[1,2,3,1,2] + Cp[1,2,1] + Cp[3,1,2]
TESTS:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: T = H.T()
sage: C = H.C()
sage: Cp = H.Cp()
sage: all(Cp(T(Cp[x])) == Cp[x] for x in W) # long time
True
sage: all(Cp(C(Cp[x])) == Cp[x] for x in W) # long time
True
Return the effect of applying the hash involution to the basis element self[w].
This function is not intended to be called directly. Instead, use hash_involution().
EXAMPLES:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: Cp=H.Cp()
sage: s=H.coxeter_group().simple_reflection(1)
sage: Cp.hash_involution_on_basis(s)
-Cp[1] + (v^-1+v)
sage: Cp[s].hash_involution()
-Cp[1] + (v^-1+v)
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra._Basis
The standard basis of Iwahori-Hecke algebra.
For every simple reflection of the Coxeter group, there is a
corresponding generator
of Iwahori-Hecke algebra. These
are subject to the relations:
together with the braid relations:
where the number of terms on each of the two sides is the order of
in the Coxeter group.
Weyl group elements form a basis of Iwahori-Hecke algebra
with the property that if
and
are Coxeter group elements
such that
then
.
With the default value and with
the
generating relation may be written
as in [I64].
EXAMPLES:
sage: H = IwahoriHeckeAlgebra("A3", 1)
sage: T = H.T()
sage: T1,T2,T3 = T.algebra_generators()
sage: T1*T2*T3*T1*T2*T1 == T3*T2*T1*T3*T2*T3
True
sage: w0 = T(H.coxeter_group().long_element())
sage: w0
T[1,2,3,1,2,1]
sage: T = H.T(prefix="s")
sage: T.an_element()
2*s[1,2,3,2,1] + 3*s[1,2,3,1] + s[1,2,3] + 1
TESTS:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: T = H.T()
sage: C = H.C()
sage: Cp = H.Cp()
sage: all(T(C(T[x])) == T[x] for x in W) # long time
True
sage: all(T(Cp(T[x])) == T[x] for x in W) # long time
True
We check a property of the bar involution and -polynomials:
sage: KL = KazhdanLusztigPolynomial(W, v)
sage: all(T[x].bar() == sum(v^(-2*y.length()) * KL.R(y, x).substitute(v=v^-2) * T[y] for y in W) for x in W) # long time
True
Bases: sage.combinat.free_module.CombinatorialFreeModuleElement
A class for elements of an Iwahori-Hecke algebra in the basis.
TESTS:
sage: R.<q> = QQ[]
sage: H = IwahoriHeckeAlgebra("B3",q).T()
sage: T1,T2,T3 = H.algebra_generators()
sage: T1+2*T2*T3
2*T[2,3] + T[1]
sage: T1*T1
(q-1)*T[1] + q
sage: R.<q1,q2> = QQ[]
sage: H = IwahoriHeckeAlgebra("A2", q1, q2=q2).T(prefix="x")
sage: sum(H.algebra_generators())^2
x[1,2] + x[2,1] + (q1+q2)*x[1] + (q1+q2)*x[2] + (-2*q1*q2)
sage: H = IwahoriHeckeAlgebra("A2", q1, q2=q2).T(prefix="t")
sage: t1,t2 = H.algebra_generators()
sage: (t1-t2)^3
(q1^2-q1*q2+q2^2)*t[1] + (-q1^2+q1*q2-q2^2)*t[2]
sage: R.<q> = QQ[]
sage: H = IwahoriHeckeAlgebra("G2", q).T()
sage: [T1, T2] = H.algebra_generators()
sage: T1*T2*T1*T2*T1*T2 == T2*T1*T2*T1*T2*T1
True
sage: T1*T2*T1 == T2*T1*T2
False
sage: H = IwahoriHeckeAlgebra("A2", 1).T()
sage: [T1,T2] = H.algebra_generators()
sage: T1+T2
T[1] + T[2]
sage: -(T1+T2)
-T[1] - T[2]
sage: 1-T1
-T[1] + 1
sage: T1.parent()
Iwahori-Hecke algebra of type A2 in 1,-1 over Integer Ring in the T-basis
Return the inverse if self is a basis element.
An element is a basis element if it is where
is in
the Weyl group. The base ring must be a field or Laurent
polynomial ring. Other elements of the ring have inverses but
the inverse method is only implemented for the basis elements.
EXAMPLES:
sage: R.<q> = LaurentPolynomialRing(QQ)
sage: H = IwahoriHeckeAlgebra("A2", q).T()
sage: [T1,T2] = H.algebra_generators()
sage: x = (T1*T2).inverse(); x
(q^-2)*T[2,1] + (q^-2-q^-1)*T[1] + (q^-2-q^-1)*T[2] + (q^-2-2*q^-1+1)
sage: x*T1*T2
1
TESTS:
We check some alternative forms of input for inverting an element:
sage: R.<q> = LaurentPolynomialRing(QQ)
sage: H = IwahoriHeckeAlgebra("A2", q).T()
sage: T1,T2 = H.algebra_generators()
sage: ~(T1*T2)
(q^-2)*T[2,1] + (q^-2-q^-1)*T[1] + (q^-2-q^-1)*T[2] + (q^-2-2*q^-1+1)
sage: (T1*T2)^(-1)
(q^-2)*T[2,1] + (q^-2-q^-1)*T[1] + (q^-2-q^-1)*T[2] + (q^-2-2*q^-1+1)
Return the bar involution of , which is
.
EXAMPLES:
sage: R.<v> = LaurentPolynomialRing(QQ)
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: W = H.coxeter_group()
sage: s1,s2,s3 = W.simple_reflections()
sage: T = H.T()
sage: b = T.bar_on_basis(s1*s2*s3); b
(v^-6)*T[1,2,3]
+ (v^-6-v^-4)*T[1,2]
+ (v^-6-v^-4)*T[3,1]
+ (v^-6-v^-4)*T[2,3]
+ (v^-6-2*v^-4+v^-2)*T[1]
+ (v^-6-2*v^-4+v^-2)*T[2]
+ (v^-6-2*v^-4+v^-2)*T[3]
+ (v^-6-3*v^-4+3*v^-2-1)
sage: b.bar()
T[1,2,3]
Return the hash involution on the basis element self[w].
The hash involution is a
-algebra
involution of the Iwahori-Hecke algebra determined by
, and
, for
an element of the
corresponding Coxeter group.
This map is defined in [KL79] and it is used to change between
the and
bases because
.
This function is not intended to be called directly. Instead, use hash_involution().
EXAMPLES:
sage: R.<v> = LaurentPolynomialRing(QQ, 'v')
sage: H = IwahoriHeckeAlgebra('A3', v**2)
sage: T=H.T()
sage: s=H.coxeter_group().simple_reflection(1)
sage: T.hash_involution_on_basis(s)
-(v^-2)*T[1]
sage: T[s].hash_involution()
-(v^-2)*T[1]
sage: h = T[1]*T[2] + (v^3 - v^-1 + 2)*T[3,1,2,3]
sage: h.hash_involution()
(v^-11+2*v^-8-v^-7)*T[1,2,3,2] + (v^-4)*T[1,2]
sage: h.hash_involution().hash_involution() == h
True
Return the inverse of the -th generator, if it exists.
This method is only available if the Iwahori-Hecke algebra parameters q1 and q2 are both invertible. In this case, the algebra generators are also invertible and this method returns the inverse of self.algebra_generator(i).
EXAMPLES:
sage: P.<q1, q2>=QQ[]
sage: F = Frac(P)
sage: H = IwahoriHeckeAlgebra("A2", q1, q2=q2, base_ring=F).T()
sage: H.base_ring()
Fraction Field of Multivariate Polynomial Ring in q1, q2 over Rational Field
sage: H.inverse_generator(1)
-1/(q1*q2)*T[1] + ((q1+q2)/(q1*q2))
sage: H = IwahoriHeckeAlgebra("A2", q1, base_ring=F).T()
sage: H.inverse_generator(2)
-(1/(-q1))*T[2] + ((q1-1)/(-q1))
sage: P1.<r1, r2> = LaurentPolynomialRing(QQ)
sage: H1 = IwahoriHeckeAlgebra("B2", r1, q2=r2, base_ring=P1).T()
sage: H1.base_ring()
Multivariate Laurent Polynomial Ring in r1, r2 over Rational Field
sage: H1.inverse_generator(2)
(-r1^-1*r2^-1)*T[2] + (r2^-1+r1^-1)
sage: H2 = IwahoriHeckeAlgebra("C2", r1, base_ring=P1).T()
sage: H2.inverse_generator(2)
(r1^-1)*T[2] + (-1+r1^-1)
Return the inverses of all the generators, if they exist.
This method is only available if q1 and q2 are invertible. In that case, the algebra generators are also invertible.
EXAMPLES:
sage: P.<q> = PolynomialRing(QQ)
sage: F = Frac(P)
sage: H = IwahoriHeckeAlgebra("A2", q, base_ring=F).T()
sage: T1,T2 = H.algebra_generators()
sage: U1,U2 = H.inverse_generators()
sage: U1*T1,T1*U1
(1, 1)
sage: P1.<q> = LaurentPolynomialRing(QQ)
sage: H1 = IwahoriHeckeAlgebra("A2", q, base_ring=P1).T(prefix="V")
sage: V1,V2 = H1.algebra_generators()
sage: W1,W2 = H1.inverse_generators()
sage: [W1,W2]
[(q^-1)*V[1] + (q^-1-1), (q^-1)*V[2] + (q^-1-1)]
sage: V1*W1, W2*V2
(1, 1)
Return , where
is the
-th generator. This is
coded individually for use in x._mul_().
EXAMPLES:
sage: R.<q> = QQ[]; H = IwahoriHeckeAlgebra("A2", q).T()
sage: T1, T2 = H.algebra_generators()
sage: [H.product_by_generator(x, 1) for x in [T1,T2]]
[(q-1)*T[1] + q, T[2,1]]
sage: [H.product_by_generator(x, 1, side = "left") for x in [T1,T2]]
[(q-1)*T[1] + q, T[1,2]]
Return the product (resp.
) if side is
'right' (resp. 'left').
If the quadratic relation is , then we have
The left action is similar.
INPUT:
EXAMPLES:
sage: R.<q> = QQ[]; H = IwahoriHeckeAlgebra("A2", q)
sage: T = H.T()
sage: s1,s2 = H.coxeter_group().simple_reflections()
sage: [T.product_by_generator_on_basis(w, 1) for w in [s1,s2,s1*s2]]
[(q-1)*T[1] + q, T[2,1], T[1,2,1]]
sage: [T.product_by_generator_on_basis(w, 1, side="left") for w in [s1,s2,s1*s2]]
[(q-1)*T[1] + q, T[1,2], (q-1)*T[1,2] + q*T[2]]
Return , where
and
are words in the
Coxeter group.
EXAMPLES:
sage: R.<q> = QQ[]; H = IwahoriHeckeAlgebra("A2", q)
sage: T = H.T()
sage: s1,s2 = H.coxeter_group().simple_reflections()
sage: [T.product_on_basis(s1,x) for x in [s1,s2]]
[(q-1)*T[1] + q, T[1,2]]
Return as a linear combination of
-basis elements.
EXAMPLES:
sage: R = LaurentPolynomialRing(QQ, 'v')
sage: v = R.gen(0)
sage: H = IwahoriHeckeAlgebra('A2', v**2)
sage: s1,s2 = H.coxeter_group().simple_reflections()
sage: T = H.T()
sage: C = H.C()
sage: T.to_C_basis(s1)
v*T[1] + v^2
sage: C(T(s1))
v*C[1] + v^2
sage: C(v^-1*T(s1) - v)
C[1]
sage: C(T(s1*s2)+T(s1)+T(s2)+1)
v^2*C[1,2] + (v+v^3)*C[1] + (v+v^3)*C[2] + (1+2*v^2+v^4)
sage: C(T(s1*s2*s1))
v^3*C[1,2,1] + v^4*C[1,2] + v^4*C[2,1] + v^5*C[1] + v^5*C[2] + v^6
Return as a linear combination of
-basis
elements.
EXAMPLES:
sage: R.<v> = LaurentPolynomialRing(QQ)
sage: H = IwahoriHeckeAlgebra('A2', v**2)
sage: s1,s2 = H.coxeter_group().simple_reflections()
sage: T = H.T()
sage: Cp = H.Cp()
sage: T.to_Cp_basis(s1)
v*Cp[1] - 1
sage: Cp(T(s1))
v*Cp[1] - 1
sage: Cp(T(s1)+1)
v*Cp[1]
sage: Cp(T(s1*s2)+T(s1)+T(s2)+1)
v^2*Cp[1,2]
sage: Cp(T(s1*s2*s1))
v^3*Cp[1,2,1] - v^2*Cp[1,2] - v^2*Cp[2,1] + v*Cp[1] + v*Cp[2] - 1
Return a particular realization of self (the -basis).
EXAMPLES:
sage: H = IwahoriHeckeAlgebra("B2", 1)
sage: H.a_realization()
Iwahori-Hecke algebra of type B2 in 1,-1 over Integer Ring in the T-basis
Return the Cartan type of self.
EXAMPLES:
sage: IwahoriHeckeAlgebra("D4", 1).cartan_type()
['D', 4]
Return the Coxeter group of self.
EXAMPLES:
sage: IwahoriHeckeAlgebra("B2", 1).coxeter_group()
Weyl Group of type ['B', 2] (as a matrix group acting on the ambient space)
Return the parameter of self.
EXAMPLES:
sage: H = IwahoriHeckeAlgebra("B2", 1)
sage: H.q1()
1
Return the parameter of self.
EXAMPLES:
sage: H = IwahoriHeckeAlgebra("B2", 1)
sage: H.q2()
-1
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra
This is a class which is used behind the scenes by
IwahoriHeckeAlgebra to compute the Kazhdan-Lusztig bases. It is
not meant to be used directly. It implements the slightly idiosyncratic
(but convenient) Iwahori-Hecke algebra with two parameters which is
defined over the Laurent polynomial ring in
two variables and has quadratic relations:
The point of these relations is that the product of the two parameters is
which is a square in
. Consequently, the
Kazhdan-Lusztig bases are defined for this algebra.
More generally, if we have a Iwahori-Hecke algebra with two parameters which has quadratic relations of the form:
where is a square then the Kazhdan-Lusztig bases are
well-defined for this algebra. Moreover, these bases be computed by
specialization from the generic Iwahori-Hecke algebra using the
specialization which sends
and
,
so that
.
For example, if and
then
and
; this is the standard presentation of the
Iwahori-Hecke algebra with
. On the other hand,
when
and
then
and
.
This is the normalized presentation with
.
Warning
This class uses non-standard parameters for the Iwahori-Hecke algebra
and are related to the standard parameters by an outer automorphism
that is non-trivial on the -basis.
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra.C
The Kazhdan-Lusztig -basis for the generic Iwahori-Hecke algebra.
Return as a linear combination of
-basis elements.
EXAMPLES:
sage: H = sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra_nonstandard("A3")
sage: s1,s2,s3 = H.coxeter_group().simple_reflections()
sage: T = H.T()
sage: C = H.C()
sage: C.to_T_basis(s1)
(v^-1)*T[1] + (-u*v^-1)
sage: C.to_T_basis(s1*s2)
(v^-2)*T[1,2] + (-u*v^-2)*T[1] + (-u*v^-2)*T[2] + (u^2*v^-2)
sage: C.to_T_basis(s1*s2*s1)
(v^-3)*T[1,2,1] + (-u*v^-3)*T[1,2] + (-u*v^-3)*T[2,1]
+ (u^2*v^-3)*T[1] + (u^2*v^-3)*T[2] + (-u^3*v^-3)
sage: T(C(s1*s2*s1))
(v^-3)*T[1,2,1] + (-u*v^-3)*T[1,2] + (-u*v^-3)*T[2,1]
+ (u^2*v^-3)*T[1] + (u^2*v^-3)*T[2] + (-u^3*v^-3)
sage: T(C(s2*s1*s3*s2))
(v^-4)*T[2,3,1,2] + (-u*v^-4)*T[1,2,1] + (-u*v^-4)*T[3,1,2]
+ (-u*v^-4)*T[2,3,1] + (-u*v^-4)*T[2,3,2] + (u^2*v^-4)*T[1,2]
+ (u^2*v^-4)*T[2,1] + (u^2*v^-4)*T[3,1] + (u^2*v^-4)*T[2,3]
+ (u^2*v^-4)*T[3,2] + (-u^3*v^-4)*T[1]
+ (-u^3*v^-4-u*v^-2)*T[2] + (-u^3*v^-4)*T[3]
+ (u^4*v^-4+u^2*v^-2)
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra.Cp
The Kazhdan-Lusztig -basis for the generic Iwahori-Hecke
algebra.
Return as a linear combination of
-basis
elements.
EXAMPLES:
sage: H = sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra_nonstandard("A3")
sage: s1,s2,s3 = H.coxeter_group().simple_reflections()
sage: T = H.T()
sage: Cp = H.Cp()
sage: Cp.to_T_basis(s1)
(v^-1)*T[1] + (u^-1*v)
sage: Cp.to_T_basis(s1*s2)
(v^-2)*T[1,2] + (u^-1)*T[1] + (u^-1)*T[2] + (u^-2*v^2)
sage: Cp.to_T_basis(s1*s2*s1)
(v^-3)*T[1,2,1] + (u^-1*v^-1)*T[1,2] + (u^-1*v^-1)*T[2,1]
+ (u^-2*v)*T[1] + (u^-2*v)*T[2] + (u^-3*v^3)
sage: T(Cp(s1*s2*s1))
(v^-3)*T[1,2,1] + (u^-1*v^-1)*T[1,2] + (u^-1*v^-1)*T[2,1]
+ (u^-2*v)*T[1] + (u^-2*v)*T[2] + (u^-3*v^3)
sage: T(Cp(s2*s1*s3*s2))
(v^-4)*T[2,3,1,2] + (u^-1*v^-2)*T[1,2,1] + (u^-1*v^-2)*T[3,1,2]
+ (u^-1*v^-2)*T[2,3,1] + (u^-1*v^-2)*T[2,3,2] + (u^-2)*T[1,2]
+ (u^-2)*T[2,1] + (u^-2)*T[3,1] + (u^-2)*T[2,3]
+ (u^-2)*T[3,2] + (u^-3*v^2)*T[1] + (u^-1+u^-3*v^2)*T[2]
+ (u^-3*v^2)*T[3] + (u^-2*v^2+u^-4*v^4)
Bases: sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra.T
The -basis for the generic Iwahori-Hecke algebra.
Return as a linear combination of
-basis elements.
To compute this we piggy back off the -basis
conversion using the observation that the hash involution sends
to
and
to
. Therefore, if
then
Note that we cannot just apply hash_involution() here because this involution always returns the answer with respect to the same basis.
EXAMPLES:
sage: H = sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra_nonstandard("A2")
sage: s1,s2 = H.coxeter_group().simple_reflections()
sage: T = H.T()
sage: C = H.C()
sage: T.to_C_basis(s1)
v*T[1] + u
sage: C(T(s1))
v*C[1] + u
sage: C(T( C[1] ))
C[1]
sage: C(T(s1*s2)+T(s1)+T(s2)+1)
v^2*C[1,2] + (u*v+v)*C[1] + (u*v+v)*C[2] + (u^2+2*u+1)
sage: C(T(s1*s2*s1))
v^3*C[1,2,1] + u*v^2*C[1,2] + u*v^2*C[2,1] + u^2*v*C[1] + u^2*v*C[2] + u^3
Return as a linear combination of
-basis
elements.
EXAMPLES:
sage: H = sage.algebras.iwahori_hecke_algebra.IwahoriHeckeAlgebra_nonstandard("A2")
sage: s1,s2 = H.coxeter_group().simple_reflections()
sage: T = H.T()
sage: Cp = H.Cp()
sage: T.to_Cp_basis(s1)
v*Cp[1] + (-u^-1*v^2)
sage: Cp(T(s1))
v*Cp[1] + (-u^-1*v^2)
sage: Cp(T(s1)+1)
v*Cp[1] + (-u^-1*v^2+1)
sage: Cp(T(s1*s2)+T(s1)+T(s2)+1)
v^2*Cp[1,2] + (-u^-1*v^3+v)*Cp[1] + (-u^-1*v^3+v)*Cp[2] + (u^-2*v^4-2*u^-1*v^2+1)
sage: Cp(T(s1*s2*s1))
v^3*Cp[1,2,1] + (-u^-1*v^4)*Cp[1,2] + (-u^-1*v^4)*Cp[2,1]
+ (u^-2*v^5)*Cp[1] + (u^-2*v^5)*Cp[2] + (-u^-3*v^6)
Compare two term indices x and y by Bruhat order, then by word length, and then by the generic comparison.
EXAMPLES:
sage: from sage.algebras.iwahori_hecke_algebra import index_cmp
sage: W = WeylGroup(['A',2,1])
sage: x = W.from_reduced_word([0,1])
sage: y = W.from_reduced_word([0,2,1])
sage: x.bruhat_le(y)
True
sage: index_cmp(x, y)
1
Returns a normalized version of the (Laurent polynomial) p in the ring R.
Various ring operations in sage return an element of the field of fractions of the parent ring even though the element is “known” to belong to the base ring. This function is a hack to recover from this. This occurs somewhat haphazardly with Laurent polynomial rings:
sage: R.<q>=LaurentPolynomialRing(ZZ)
sage: [type(c) for c in (q**-1).coefficients()]
[<type 'sage.rings.integer.Integer'>]
It also happens in any ring when dividing by units:
sage: type ( 3/1 )
<type 'sage.rings.rational.Rational'>
sage: type ( -1/-1 )
<type 'sage.rings.rational.Rational'>
This function is a variation on a suggested workaround of Nils Bruin.
EXAMPLES:
sage: from sage.algebras.iwahori_hecke_algebra import normalized_laurent_polynomial
sage: type ( normalized_laurent_polynomial(ZZ, 3/1) )
<type 'sage.rings.integer.Integer'>
sage: R.<q>=LaurentPolynomialRing(ZZ)
sage: [type(c) for c in normalized_laurent_polynomial(R, q**-1).coefficients()]
[<type 'sage.rings.integer.Integer'>]
sage: R.<u,v>=LaurentPolynomialRing(ZZ,2)
sage: p=normalized_laurent_polynomial(R, 2*u**-1*v**-1+u*v)
sage: ui=normalized_laurent_polynomial(R, u^-1)
sage: vi=normalized_laurent_polynomial(R, v^-1)
sage: p(ui,vi)
2*u*v + u^-1*v^-1
sage: q= u+v+ui
sage: q(ui,vi)
u + v^-1 + u^-1