Kazhdan-Lusztig polynomials and bases
Chevie.KL
Chevie.KL.AsymptoticAlgebra
Chevie.KL.LeftCell
Chevie.Chars.WGraphToRepresentation
Chevie.Chars.representation
Chevie.HeckeAlgebras.Tbasis
Chevie.KL.Cbasis
Chevie.KL.Cpbasis
Chevie.KL.KLPol
Chevie.KL.LusztigAw
Chevie.KL.Lusztigaw
Chevie.KL.Wgraph
Chevie.KL.character
Chevie.KL.critical_pair
Chevie.KL.left_cells
Chevie.KL
— ModuleThis module defines Kazhdan-Lusztig polynomials and bases, and computes W-graphs and asymptotic algebras.
Let ℋ
be the Iwahori-Hecke algebra of a Coxeter system (W,S)
, with quadratic relations (Tₛ-uₛ₀)(Tₛ-uₛ₁)=0
for s∈ S
. If -uₛ₀uₛ₁
has a square root wₛ
, we can scale the basis Tₛ
to get a new basis tₛ=-Tₛ/wₛ
with quadratic relations (tₛ-vₛ)(tₛ+vₛ⁻¹)=0
where vₛ=wₛ/uₛ₁
. The most general case when Kazhdan-Lusztig bases and polynomials can be defined is when the parameters vₛ
belong to a totally ordered abelian group Γ
for multiplication, see Lusztig1983. We set Γ⁺= {γ∈ Γ∣γ>0}
and Γ⁻={γ⁻¹∣γ∈ Γ⁺}={γ∈ Γ∣γ<0}
.
Thus we assume ℋ
defined over the ring ℤ[Γ]
, the group algebra of Γ
over ℤ
, and the quadratic relations of ℋ
associate to each s∈ S
a vₛ∈ Γ⁺
such that (tₛ-vₛ)(tₛ+vₛ⁻¹)=0
. We also set qₛ=vₛ²
and define the basis Tₛ=vₛtₛ
with quadratic relations (Tₛ-qₛ)(Tₛ+1)=0
; for w∈ W
with reduced expression w=s₁…sₙ
we define $q_w∈ Γ⁺$ by $q_w^½=v_{s₁}…v_{sₙ}$ and let $q_w=(q_w^½)²$; we have $T_w=q_w^½t_w$.
We define the bar involution on ℋ
by linearity: on ℤ[Γ]
we define it by $\overline{∑_{γ∈ Γ}a_γγ}= ∑_{γ∈ Γ} a_γ γ⁻¹$ and we extend it to ℋ
by $\overline T_s=T_s^{-1}$ (equivalently $\overline t_s=t_s^{-1}$). Then the Kazhdan-Lusztig basis $C^′_w$ is defined as the only basis of ℋ
stable by the bar involution and congruent to $t_w$ modulo $∑_{w∈ W}Γ⁻.t_w$.
The basis $C^′_w$ can be computed as follows. We define elements $R_{x,y}$ of ℤ[Γ]
by $T_y⁻¹=∑_x \overline{R_{x,y⁻¹}} q_x⁻¹T_x$. We then define inductively the Kazhdan-Lusztig polynomials (in this general context we should say the Kazhdan-Lusztig elements of ℤ[Γ]
, which belong to the subalgebra of ℤ[Γ]
generated by the qₛ
) by $P_{x,w}=τ_{≤(q_w/q_x)^½} (∑_{x<y≤w}R_{x,y}P_{y,w})$ where τ
is the truncation: $τ_≤\nu ∑_{γ∈ Γ} a_γγ= ∑_{γ≤\nu}a_γγ$; the induction is thus on decreasing x
for the Bruhat order and starts at $P_{w,w}=1$. We have then $C^′_w=∑_y q_w^{-1/2} P_{y,w}T_y$.
The Chevie code for the Kazhdan-Lusztig bases C
, D
, C'
, D'
, was originally written by Andrew Mathas around 1994, who also contributed to the design of bases of Iwahori-Hecke algebras and implemented some other bases, such as the Murphy basis. Our code evolved from that code. The code for the case of unequal parameters was written around 1999 by F.Digne and J.Michel. The Kazhdan-Lusztig bases are computed starting from the C′
basis.
When the ℤ[Γ]
is a Laurent polynomial ring the bar operation is taking the inverse of the variables, and truncation is keeping terms of degree smaller or equal to that of ν
. It is possible to use arbitrary groups Γ
as long as methods bar
:$∑_{γ∈ Γ} a_γγ↦ ∑_{γ∈ Γ} a_γγ⁻¹$, positive_part
: $∑_{γ∈ Γ} a_γγ↦ ∑_{γ≥ 1} a_γγ$ and negative_part
: $∑_{γ∈ Γ} a_γγ ↦ ∑_{γ≤ 1} a_γγ$ have been defined on ℤ[Γ]
. These operations will be used internally by the programs to compute Kazhdan-Lusztig bases.
We provide also functionality to study the Kazhdan-Lusztig left cells (for the equal-parameter Hecke algebra).
julia> W=coxgroup(:H,3)
H₃
julia> c=left_cells(W)
22-element Vector{LeftCell{FiniteCoxeterGroup{Perm{Int16},Cyc{Int64}}}}:
LeftCell<H₃: duflo= character=φ₁‚₀>
LeftCell<H₃: duflo=123 character=φ₁‚₁₅>
LeftCell<H₃: duflo=(15) character=φ₅‚₅>
LeftCell<H₃: duflo=(10) character=φ₅‚₅>
LeftCell<H₃: duflo=(14) character=φ₅‚₅>
LeftCell<H₃: duflo=7 character=φ₅‚₅>
LeftCell<H₃: duflo=(12) character=φ₅‚₅>
LeftCell<H₃: duflo=(9,12) character=φ₅‚₂>
LeftCell<H₃: duflo=(5,11) character=φ₅‚₂>
LeftCell<H₃: duflo=13 character=φ₅‚₂>
⋮
LeftCell<H₃: duflo=(8,13) character=φ₃‚₆+φ₃‚₈>
LeftCell<H₃: duflo=(1,15) character=φ₃‚₆+φ₃‚₈>
LeftCell<H₃: duflo=3 character=φ₃‚₁+φ₃‚₃>
LeftCell<H₃: duflo=2 character=φ₃‚₁+φ₃‚₃>
LeftCell<H₃: duflo=1 character=φ₃‚₁+φ₃‚₃>
LeftCell<H₃: duflo=6 character=φ₄‚₃+φ₄‚₄>
LeftCell<H₃: duflo=(13) character=φ₄‚₃+φ₄‚₄>
LeftCell<H₃: duflo=(11) character=φ₄‚₃+φ₄‚₄>
LeftCell<H₃: duflo=9 character=φ₄‚₃+φ₄‚₄>
see also the functions elements
, character
, representation
and Wgraph
for left cells. The operations length
, in
(which refer to elements
) and ==
(which compares Duflo involutions) are also defined for left cells. When character(c)
has been computed, then c.a
also has been bound which holds the common value of Lusztig's a
-function for the elements of c
and the irreducible constituents of character(c)
.
finally, benchmarks
julia> function test_kl(W)
q=Pol(); H=hecke(W,q^2,rootpara=q)
C=Cpbasis(H); T=Tbasis(H)
[T(C(w)) for w in elements(W)]
end
test_kl (generic function with 1 method)
julia> @btime test_kl(coxgroup(:F,4)); #julia 1.8
1.332 s (13934392 allocations: 2.27 GiB)
in GAP3 the following function takes 11s for W=F4
test_kl:=function(W)local q,H,T,C;
q:=X(Rationals);H:=Hecke(W,q^2,q);
T:=Basis(H,"T");C:=Basis(H,"C'");
List(Elements(W),e->T(C(e)));
end;
Another benchmark:
function test_kl2(W)
el=elements(W)
[KLPol(W,x,y) for x in el, y in el]
end
test_kl2 (generic function with 1 method)
julia>@btime test_kl2(coxgroup(:F,4)); # julia 1.9
4.307 s (42294917 allocations: 5.24 GiB)
in GAP3 the following function takes 42s for F4
test_kl2:=function(W)local el;
el:=Elements(W);
List(el,x->List(el,y->KazhdanLusztigPolynomial(W,x,y)));
end;
Chevie.KL.KLPol
— FunctionKLPol(W,y,w)
returns the Kazhdan-Lusztig polynomial P_{y,w}
of W
.
To compute Kazhdan-Lusztig polynomials in the one-parameter case it still seems best to use the recursion formula in the original paper KL79. We first perform a series of checks on the pair (y,w)
to see if the computation of the corresponding polynomial can be reduced to a similar calculation for elements of smaller length. In particular, we reduce to the case of critical pairs (see KL.critical_pair
), and whenever the polynomial corresponding to such a pair is computed, the value is stored in a Dict
W.klpol
in the underlying Coxeter group.
julia> W=coxgroup(:B,3)
B₃
julia> map(i->map(x->KLPol(W,one(W),x),elements(W,i)),1:nref(W))
9-element Vector{Vector{Pol{Int64}}}:
[1, 1, 1]
[1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, 1, 1]
[1, 1, 1, 1, 1, x+1, 1, 1]
[x+1, 1, x+1, x+1, 1, 1, x+1, 1]
[x²+1, 1, x+1, x+1, x+1, 1, 1]
[1, 1, x²+x+1, x+1, x+1]
[1, x+1, x²+1]
[1]
Our code is based on Meinolf Geck's code for GAP3/Chevie.
Chevie.KL.critical_pair
— Functioncritical_pair(W, y, w)
returns the critical pair z≤w associated to y≤w (see Alvis1987).
Let ℒ
(resp. ℛ
) be the left (resp. right) descent set. A pair of elements y≤w of W is called critical if ℒ(y)⊃ ℒ(w)
and ℛ (y)⊃ ℛ (w)
. If y≤w is not critical, y can be multiplied from the left (resp. the right) by an element of ℒ(w)
(resp. ℛ (w)
) which is not in ℒ (y)
(resp. ℛ (y)
) until we get a critical pair z≤w. The function returns z. If y≤w then y≤z≤w.
The significance of this construction is that KLPol(W,y,w)==KLPol(W,z,w)
julia> W=coxgroup(:F,4)
F₄
julia> w=longest(W)*gens(W)[1];length(W,w)
23
julia> y=W(1:4...);length(W,y)
4
julia> cr=KL.critical_pair(W,y,w);length(W,cr)
16
julia> Pol(:x);KLPol(W,y,w)
Pol{Int64}: x³+1
julia> KLPol(W,cr,w)
Pol{Int64}: x³+1
Chevie.HeckeAlgebras.Tbasis
— MethodTbasis(h::HeckeCpElt)
converts the element h
of the C'
basis to the T
basis.
For one-parameter Hecke algebras, we use the formulae: $C'_w=Σ_{y≤w}P_{y,w}(q)q^{-l(w)/2}T_y$ and if $sw<w$ then
$C'ₛ C'_{sw}=C'_w+Σ_{y<sw}μ(y,sw)C'_y=Σ_{v≤w}μᵥ Tᵥ$
where
$μᵥ=P_{v,w}(q)q^{-l(w)/2}+Σ_{v≤y≤sw}μ(y,sw)P_{v,y}(q)q^{-l(y)/2}$
It follows that if $deg(μᵥ)>=-l(v)$ then $deg(μᵥ)=-l(v)$ with leading coefficient $μ(v,sw)$ (this happens exactly for $y=v$ in the sum which occurs in the formula for $μᵥ$).
julia> W=coxgroup(:B,3)
B₃
julia> @Pol v;H=hecke(W,v^2,rootpara=v)
hecke(B₃,v²,rootpara=v)
julia> C=Cpbasis(H); Tbasis(C(1,2))
v⁻²T.+v⁻²T₂+v⁻²T₁+v⁻²T₁₂
For general Hecke algebras, we follow formula 2.2 in Lusztig1983
$\overline{P_{x,w}}-P_{x,w}=∑_{x<y≤w} R_{x,y} P_{y,w}$
where $R_{x,y}=\overline{(t_{y^{-1}}^{-1}|t_x)}$ where t
is the basis with parameters $q_s,-q_s^{-1}$. It follows that $P_{x,w}$ is the negative part of $∑_{x<y≤w} R_{x,y} P_{y,w}$ which allows to compute it by induction on l(w)-l(x)
. The code is based on GAP3/Chevie code of Jean Michel and François Digne (1999).
Chevie.KL.Cbasis
— FunctionCbasis(H::HeckeAlgebra)
returns a function which gives the C
-basis of the Iwahori-Hecke algebra H
. The algebra H
should have the functon rootpara
defined. This basis is defined as follows (see e.g. (5.1)Lusztig1985). Let W
be the underlying Coxeter group. For x,y ∈ W
let $P_{x,y}$ be the corresponding Kazhdan–Lusztig polynomial. If $\{T_w ∣ w∈ W\}$ denotes the usual T-basis, then $C_x=\sum_{y\le x}(-1)^{l(x)-l(y)}P_{y,x}(q^{-1})q_x^{1/2}q_y^{-1} T_y$ for x ∈ W
. For example, we have Cₛ=qₛ⁻½Tₛ-qₛ½T₁
for s ∈ S
. Thus, the transformation matrix between the T
-basis and the C
-basis is lower unitriangular, with monomials in qₛ
along the diagonal. In the one-parameter case (all qₛ
are equal to v²
) the multiplication rules for the C
basis are given by:
Cₛ⋅Cₓ =-(v+v⁻¹)Cₓ
, if sx<x
, and Cₛₓ+∑ₜ μ(t,x)Cₜ
if sx>x
.
where the sum is over all t
such that t<x
, l(t)
and l(x)
have different parity and st<t
. The coefficient μ(t,x)
is the coefficient of degree (l(x)-l(t)-1)/2
in the Kazhdan–Lusztig polynomial $P_{x,t}$.
The returned function can take as argument a list of integers (as a vector or as a list of arguments), representing a Coxeter word, an element of the Coxeter group, or a Hecke element (converted then to the C'
basis).
julia> W=coxgroup(:B,3);H=hecke(W,Pol(:v)^2)
hecke(B₃,v²)
julia> T=Tbasis(H);C=Cbasis(H);T(C(1))
-vT.+v⁻¹T₁
julia> C(T(1))
v²C.+vC₁
We can also compute character values on elements in the C
-basis as follows:
julia> ref=reflrep(H)
3-element Vector{Matrix{Pol{Int64}}}:
[-1 0 0; -v² v² 0; 0 0 v²]
[v² -2 0; 0 -1 0; 0 -v² v²]
[v² 0 0; 0 v² -1; 0 0 -1]
julia> c=CharTable(H).irr[charinfo(W).extRefl[[2]],:]
1×10 Matrix{Pol{Int64}}:
3 2v²-1 v⁸-2v⁴ -3v¹² 2v²-1 v⁴ v⁴-2v² -v⁶ v⁴-v² 0
julia> hcat(char_values.(C.(classreps(W)),Ref(c))...)
1×10 Matrix{Pol{Int64}}:
3 -v-v⁻¹ 0 0 -v-v⁻¹ 2 0 0 1 0
Chevie.KL.Cpbasis
— FunctionCpbasis(H)
returns a function which gives the C'
-basis of the Iwahori-Hecke algebra H
(see (5.1)Lusztig1985). This basis is defined by $C'_x= ∑_{y≤x}P_{y,x}q_x^{-1/2} T_y$ for x ∈ W
. We have $C'_x=(-1)^{l(x)}alt(C_x)$ for all x ∈ W
(see alt
). The returned function can take as argument a list of integers (as a vector or as a list of arguments), representing a Coxeter word, an element of the Coxeter group, or a Hecke element (converted then to the C'
basis).
julia> W=coxgroup(:B,2);@Pol v;H=hecke(W,[v^4,v^2])
hecke(B₂,Pol{Int64}[v⁴, v²])
julia> Cp=Cpbasis(H);h=Cp(1)^2
(v²+v⁻²)C′₁
julia> k=Tbasis(h)
(1+v⁻⁴)T.+(1+v⁻⁴)T₁
julia> Cp(k)
(v²+v⁻²)C′₁
Chevie.KL.character
— Functioncharacter(c)
Returns a list l
such that the character of c.group
afforded by the left cell c
is sum(CharTable(c.group).irr[l])
.
julia> c=left_cells(coxgroup(:G,2))[3]
LeftCell<G₂: duflo=2 character=φ₂‚₁+φ′₁‚₃+φ₂‚₂>
julia> character(c)
3-element Vector{Int64}:
3
5
6
Chevie.Chars.representation
— Methodrepresentation(c::LeftCell,H)
returns matrices giving the representation of the Iwahori-Hecke algebra H
on the left cell c
.
julia> W=coxgroup(:H,3)
H₃
julia> c=left_cells(W)[3]
LeftCell<H₃: duflo=(15) character=φ₅‚₅>
julia> @Mvp q;H=hecke(W,q)
hecke(H₃,q)
julia> representation(c,H)
3-element Vector{Matrix{Mvp{Int64, Rational{Int64}}}}:
[-1 0 … 0 0; 0 -1 … 0 -q½; … ; 0 0 … q 0; 0 0 … 0 q]
[-1 -q½ … 0 0; 0 q … 0 0; … ; 0 0 … -1 0; 0 -q½ … 0 -1]
[q 0 … 0 0; -q½ -1 … 0 0; … ; 0 0 … q 0; 0 0 … 0 -1]
Chevie.Chars.WGraphToRepresentation
— FunctionWGraphToRepresentation(coxrank::Integer,graph,v)
We store some representations of one-parameter Iwahori-Hecke algebras as W
-graphs. For a Coxeter system (W,S)
, a W
-graph is defined by a set of vertices C
with a function I
which attaches to x∈ C
a subset I(x)⊂ S
, and edge labels which to (x,y)∈ C^2
attach μ(x,y)∈ K
where K
is the field of definition of W
; this defines a representation of the Hecke algebra with parameters v
and -v⁻¹
on a space with basis ${e_y}_{y∈ C}$ by:
$Tₛ(e_y)=-e_y$ if s∈ I(y)
and otherwise $Tₛ(e_y)=v^2 e_y+∑_{x∣s∈ I(x)} vμ(x,y)eₓ$.
The W
-graphs are stored in a compact format to save space. They are represented as a pair.
The first element is a list describing
C
. Its elements are either a vectorI(x)
of indices ineachindex(S)
, or an integern
specifying to repeat the previous elementn
more times.The second element is a list which specifies
μ
.
We first describe the μ
-list for symmetric W
-graphs (when μ(x,y)=μ(y,x)
). There is one element of the μ
-list for each non-zero value m
taken by μ
, which consists of a pair whose first element is m
and whose second element is a list of lists; if l
is one of these lists each pair [l[1],l[i]]
represents an edge (x=l[1]
,y=l[i]
) such that μ(x,y)=μ(y,x)=m
. For non-symmetric W
-graphs, the first element of each pair in the μ
-list is a pair [m1,m2]
and each edge [x,y]
obtained from the lists in the second element has to be interpreted as μ(x,y)=m1
and μ(y,x)=m2
.
julia> W=coxgroup(:H,3)
H₃
julia> g=Wgraph(W,3)
2-element Vector{Vector{Vector{Any}}}:
[[2], [1, 2], [1, 3], [1, 3], [2, 3]]
[[-1, [[1, 3], [2, 4], [3, 5], [4, 5]]]]
julia> WGraphToRepresentation(3,g,Pol(:x))
3-element Vector{Matrix{Pol{Int64}}}:
[x² 0 … 0 0; 0 -1 … 0 0; … ; 0 0 … -1 -x; 0 0 … 0 x²]
[-1 0 … 0 0; 0 -1 … -x 0; … ; 0 0 … x² 0; 0 0 … -x -1]
[x² 0 … 0 0; 0 x² … 0 0; … ; 0 -x … -1 0; 0 0 … 0 -1]
WGraphToRepresentation(H::HeckeAlgebra,gr::Vector)
H
should be a one-parameter Hecke algebra for a finite Coxeter group where rootpara
is defined. The function returns the matrices of the representation of H
defined by the W-graph gr
.
julia> W=coxgroup(:H,3)
H₃
julia> H=hecke(W,Pol(:q)^2)
hecke(H₃,q²)
julia> g=Wgraph(W,3)
2-element Vector{Vector{Vector{Any}}}:
[[2], [1, 2], [1, 3], [1, 3], [2, 3]]
[[-1, [[1, 3], [2, 4], [3, 5], [4, 5]]]]
julia> WGraphToRepresentation(H,g)
3-element Vector{Matrix{Pol{Int64}}}:
[q² 0 … 0 0; 0 -1 … 0 0; … ; 0 0 … -1 q; 0 0 … 0 q²]
[-1 0 … 0 0; 0 -1 … q 0; … ; 0 0 … q² 0; 0 0 … q -1]
[q² 0 … 0 0; 0 q² … 0 0; … ; 0 q … -1 0; 0 0 … 0 -1]
Chevie.KL.Wgraph
— FunctionWgraph(c::LeftCell)
return the W-graph for a left cell for the one-parameter Hecke algebra of a finite Coxeter group.
Wgraph(W::CoxeterGroup,i)
return the W-graph for the i
-th irreducible representation of W
(or of the 1-parameter Hecke algebra of W
).
Only implemented for irreducible groups of type E
, F
or H
.
Chevie.KL.left_cells
— Functionleft_cells(W[,i])
left cells of W
[in i
-th 2-sided cell] for the 1-parameter Hecke algebra hecke(W,q)
The program uses precomputed data(see Geck-Halls 2014) for exceptional types and for type :A
, so is quite fast for these types (it takes 13 seconds to compute the 101796 left cells for type E₈
). For other types, left cells are computed from first principles, thus computing many Kazhdan-Lusztig polynomials. It takes 30 seconds to compute the left cells of D₆
, for example.
julia> W=coxgroup(:G,2)
G₂
julia> left_cells(W)
4-element Vector{LeftCell{FiniteCoxeterGroup{Perm{Int16},Int64}}}:
LeftCell<G₂: duflo= character=φ₁‚₀>
LeftCell<G₂: duflo=12 character=φ₁‚₆>
LeftCell<G₂: duflo=2 character=φ₂‚₁+φ′₁‚₃+φ₂‚₂>
LeftCell<G₂: duflo=1 character=φ₂‚₁+φ″₁‚₃+φ₂‚₂>
Printing such a record displays the character afforded by the left cell and its Duflo involution; the Duflo involution r
is printed as a subset I
of 1:nref(W)
such that r=longest(reflection_subgroup(W,I))
, see describe_involution
.
If a second argument i
is given, the program returns only the left cells which are in the i
-th two-sided cell, that is whose character is in the i
-th family of W
(see Families
).
julia> W=coxgroup(:G,2);
julia> left_cells(W,1)
2-element Vector{LeftCell{FiniteCoxeterGroup{Perm{Int16},Int64}}}:
LeftCell<G₂: duflo=2 character=φ₂‚₁+φ′₁‚₃+φ₂‚₂>
LeftCell<G₂: duflo=1 character=φ₂‚₁+φ″₁‚₃+φ₂‚₂>
Chevie.KL.LeftCell
— TypeLeftCell(W,w)
returns a record describing the left cell of W
for hecke(W,q)
containing element w
.
julia> W=coxgroup(:E,8)
E₈
julia> LeftCell(W,W((1:8)...))
LeftCell<E₈: duflo=(42,43) character=φ₃₅‚₂>
Chevie.KL.Lusztigaw
— FunctionLusztigaw(W,w)
For w
an element of the Coxeter groups W
, this function returns the coefficients on the irreducible characters of the virtual Character ca_w
defined in 5.10.2 Lusztig1985. This character has the property that the corresponding almost character is integral and positive.
julia> W=coxgroup(:G,2)
G₂
julia> l=Lusztigaw(W,W(1))
6-element Vector{Int64}:
0
0
1
0
1
1
julia> sum(l.*map(i->almostchar(W,i),eachindex(l)))
[G₂]:<φ′₁‚₃>+<φ₂‚₁>+<φ₂‚₂>
Chevie.KL.LusztigAw
— FunctionLusztigAw( <W>, <w>)
For <w> an element of the Coxeter groups <W>, this function returns the coefficients on the irreducible characters of the virtual Character cA_w defined in 5.11.6 Lusztig1985. This character has the property that the corresponding almost character is integral and positive.
julia> W=coxgroup(:G,2)
G₂
julia> l=LusztigAw(W,W(1))
6-element Vector{Int64}:
0
0
0
1
1
1
julia> sum(l.*map(i->almostchar(W,i),eachindex(l)))
[G₂]:<φ″₁‚₃>+<φ₂‚₁>+<φ₂‚₂>
Chevie.KL.AsymptoticAlgebra
— TypeAsymptoticAlgebra(W,i)
The asymptotic algebra A
associated to the algebra H=Hecke(W,q)
is an algebra with basis $\{tₓ\}_{x∈ W}$ and structure constants $t_xt_y=\sum_z γ_{x,y,z} t_z$ given by: let $h_{x,y,z}$ be the coefficient of $C_x C_y$ on $C_z$. Then $h_{x,y,z}=γ_{x,y,z^{-1}} q^{a(z)/2}+$lower terms, where $q^{a(z)/2}$ is the maximum over x,y
of the degree of $h_{x,y,z}$.
The algebra A
is the direct product of the subalgebras $A_{\mathcal C}$ generated by the elements $\{t_x\}_{x∈{\mathcal C}}$, where $\mathcal C$ runs over the two-sided cells of W
. If $\mathcal C$ is the i
-th two-sided cell of W
, the command AsymptoticAlgebra(W,i)
returns the algebra $A_{\mathcal C}$. Note that the function a(z)
is constant over a two-sided cell, equal to the common value of the a
-function attached to the characters of the two-sided cell (see Character
for left cells).
julia> W=coxgroup(:G,2)
G₂
julia> A=AsymptoticAlgebra(W,1)
AsymptoticAlgebra(G₂,1) dim.10
julia> b=basis(A)
10-element Vector{AlgebraElt{AsymptoticAlgebra, Int64}}:
t₂
t₁₂
t₂₁₂
t₁₂₁₂
t₂₁₂₁₂
t₁
t₂₁
t₁₂₁
t₂₁₂₁
t₁₂₁₂₁
julia> b*permutedims(b)
10×10 Matrix{AlgebraElt{AsymptoticAlgebra, Int64}}:
t₂ 0 t₂₁₂ … 0 t₂₁₂₁ 0
t₁₂ 0 t₁₂+t₁₂₁₂ 0 t₁₂₁+t₁₂₁₂₁ 0
t₂₁₂ 0 t₂+t₂₁₂+t₂₁₂₁₂ 0 t₂₁+t₂₁₂₁ 0
t₁₂₁₂ 0 t₁₂+t₁₂₁₂ 0 t₁+t₁₂₁ 0
t₂₁₂₁₂ 0 t₂₁₂ 0 t₂₁ 0
0 t₁₂ 0 … t₁₂₁ 0 t₁₂₁₂₁
0 t₂+t₂₁₂ 0 t₂₁+t₂₁₂₁ 0 t₂₁₂₁
0 t₁₂+t₁₂₁₂ 0 t₁+t₁₂₁+t₁₂₁₂₁ 0 t₁₂₁
0 t₂₁₂+t₂₁₂₁₂ 0 t₂₁+t₂₁₂₁ 0 t₂₁
0 t₁₂₁₂ 0 t₁₂₁ 0 t₁
julia> CharTable(A)
CharTable(AsymptoticAlgebra(G₂,1) dim.10)
┌─────┬───────────────────────────────────────┐
│ │2 12 212 1212 21212 1 21 121 2121 12121│
├─────┼───────────────────────────────────────┤
│φ′₁‚₃│. . . . . 1 . -1 . 1│
│φ₂‚₁ │1 . 2 . 1 1 . 2 . 1│
│φ₂‚₂ │1 . . . -1 1 . . . -1│
│φ″₁‚₃│1 . -1 . 1 . . . . .│
└─────┴───────────────────────────────────────┘