Kazhdan-Lusztig polynomials and bases

Chevie.KLModule

This 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;
source
Chevie.KL.KLPolFunction

KLPol(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.

source
Chevie.KL.critical_pairFunction

critical_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
source
Chevie.HeckeAlgebras.TbasisMethod

Tbasis(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).

source
Chevie.KL.CbasisFunction

Cbasis(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 ) 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
source
Chevie.KL.CpbasisFunction

Cpbasis(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′₁
source
Chevie.KL.characterFunction

character(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
source
Chevie.Chars.representationMethod

representation(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]
source
Chevie.Chars.WGraphToRepresentationFunction

WGraphToRepresentation(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 vector I(x) of indices in eachindex(S), or an integer n specifying to repeat the previous element n 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]
source

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]
source
Chevie.KL.WgraphFunction

Wgraph(c::LeftCell)

return the W-graph for a left cell for the one-parameter Hecke algebra of a finite Coxeter group.

source

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.

source
Chevie.KL.left_cellsFunction

left_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=φ₂‚₁+φ″₁‚₃+φ₂‚₂>
source
Chevie.KL.LeftCellType

LeftCell(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=φ₃₅‚₂>
source
Chevie.KL.LusztigawFunction

Lusztigaw(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₂]:<φ′₁‚₃>+<φ₂‚₁>+<φ₂‚₂>
source
Chevie.KL.LusztigAwFunction

LusztigAw( <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₂]:<φ″₁‚₃>+<φ₂‚₁>+<φ₂‚₂>
source
Chevie.KL.AsymptoticAlgebraType

AsymptoticAlgebra(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 .  .   .    .     .│
└─────┴───────────────────────────────────────┘
source