Let $𝐆$ be a connected reductive group over the algebraic closure of a finite field $𝔽_q$, defined over $𝔽_q$ with corresponding Frobenius automorphism $F$. We want to study the irreducible characters of $𝐆 ^F$. More generally we consider $𝐆 ^F$ where $F$ is an isogeny of $𝐆$ such that a power is a Frobenius (this covers the Suzuki and Ree groups).

If $𝐓$ is an $F$-stable maximal torus of $𝐆$, and $𝐁$ is a (not necessarily $F$-stable) Borel subgroup containing $𝐓$, we define the Deligne-Lusztig variety $X_𝐁=\{g𝐁 ∈ 𝐆 /𝐁 ∣ g𝐁 ∩ F(g𝐁 )≠∅ \}$. This variety affords a natural action of $𝐆 ^F$ on the left, so the corresponding Deligne-Lusztig virtual module $H^*_c(X_𝐁):=∑ᵢ (-1)ⁱ Hⁱ_c(X_𝐁,ℚ̄ _ℓ)$ also. The (virtual) character of this module is the Deligne-Lusztig character $R_𝐓 ^𝐆 (1)$; the notation reflects the theorem that this character does not depend on the choice of $𝐁$. This character can be parameterized by an $F$-conjugacy class of $W$: if $𝐓₀⊂𝐁₀$ is an $F$-stable pair, there is an unique $w∈ W=N_𝐆 (𝐓₀)/𝐓₀$ such that the triple $(𝐓,𝐁,F)$ is $𝐆$-conjugate to $(𝐓₀,𝐁₀,wF)$. We will thus denote $R_w$ for $R_𝐓^𝐆 (1)$; this character depends only on the $F$-class of $w$.

The unipotent characters of $𝐆 ^F$ are the irreducible constituents of the $R_w$. In a similar way that the Jordan decomposition shows that the unipotent classes are a building block for describing the conjugacy classes of a reductive group, Lusztig has defined a Jordan decomposition of characters where the unipotent characters are the building block. The unipotent characters are parameterized by combinatorial data that Lusztig has defined just from the coset $Wφ$, where φ is the finite order automorphism of $X(𝐓₀)$ such that $F=qφ$. Thus, from our viewpoint, unipotent characters are objects combinatorially attached to a Coxeter coset.

A subset of the unipotent characters, the principal series unipotent characters, can be described in a more elementary way. They are the constituents of $R₁$, or equivalently the characters of the virtual module $H^*_c(X_{𝐁 ₀})$, where $X_{𝐁 ₀}$ is the discrete variety $(𝐆 /𝐁₀)^F$; this virtual module reduces to the actual module $ℚ̄ _ℓ[(𝐆 /𝐁₀) ^F]$. Thus the Deligne-Lusztig induction $R_{𝐓₀}^𝐆 (1)$ reduces to Harish-Chandra induction, defined as follows: let $𝐏 =𝐔 ⋊ 𝐋$ be an $F$-stable Levi decomposition of an $F$-stable parabolic subgroup of $𝐆$. Then the Harish-Chandra induced $R_𝐋^𝐆$ of a character $χ$ of $𝐋^F$ is the character $Ind_{𝐏^F}^{𝐆 ^F}χ̃$, where $χ̃$ is the lift to $𝐏^F$ of $χ$ via the quotient $𝐏^F/𝐔 ^F=𝐋^F$; Harish-Chandra induction is a particular case of Lusztig induction, which is defined when $𝐏$ is not $F$-stable using the variety $X_𝐔 =\{ g𝐔 ∈𝐆 /𝐔 ∣ g𝐔 ∩ F(g𝐔 )≠∅\}$, and gives for an $𝐋^F$-module a virtual $𝐆 ^F$-module. Like ordinary induction, these functors have adjoint functors going from representations of $𝐆 ^F$ to representations (resp. virtual representations) of $𝐋^F$ called Harish-Chandra restriction (resp. Lusztig restriction).

The commuting algebra of $𝐆^F$-endomorphisms of $R₁=R_{𝐓₀}^𝐆(1)$ is an Iwahori-Hecke algebra for $W^φ$, with parameters some powers of q; the parameters are all equal to q when $W^φ=W$. Thus principal series unipotent characters are parametrized by characters of $W^φ$.

To understand the decomposition of more general $R_w$, and thus parameterize unipotent characters, is is useful to introduce another set of class functions which are parameterized by irreducible characters of the coset $Wφ$. If $χ$ is such a character, we define the associated almost character by: $Rᵪ=|W|⁻¹∑_{w∈ W}χ(wφ) R_w$. The name reflects that these class function are close to irreducible characters. They satisfy $⟨Rᵪ, R_ψ⟩_{𝐆^F}=δ_{χ,ψ}$; for the linear and unitary group they are actually unipotent characters (up to sign in the latter case). They are in general the sum (with rational coefficients) of a small number of unipotent characters in the same Lusztig family, see Families. The degree of $Rᵪ$ is a polynomial in $q$ equal to the fake degree of the character $χ$ of $Wφ$ (see fakedegree).

We now describe the parameterization of unipotent characters when $W^φ=W$, thus when the coset $Wφ$ identifies with $W$ (the situation is similar but a bit more difficult to describe in general). The (rectangular) matrix of scalar products $⟨ρ, Rᵪ⟩_{𝐆 ^F}$, when characters of $W$ and unipotent characters are arranged in the right order, is block-diagonal with rather small blocks which are called Lusztig families.

For the characters of $W$ a family 𝓕 corresponds to a block of the Hecke algebra over a ring called the Rouquier ring. To 𝓕 Lusztig associates a small group $Γ$ (not bigger than $(ℤ/2)ⁿ$, or $𝔖ᵢ$ for $i≤5$) such that the unipotent characters in the family are parameterized by the pairs $(x,θ)$ taken up to $Γ$-conjugacy, where $x∈Γ$ and $θ$ is an irreducible character of $C_Γ(x)$. Further, the elements of 𝓕 themselves are parameterized by a subset of such pairs, and Lusztig defines a pairing between such pairs which computes the scalar product $⟨ρ, Rᵪ⟩_{𝐆^F}$, called the Lusztig Fourier matrix. For more details see drinfeld_double.

A second parameterization of unipotent character is via Harish-Chandra series. A character is called cuspidal if all its proper Harish-Chandra restrictions vanish. There are few cuspidal unipotent characters (none in $GLₙ$ for $n>1$, and at most one in other classical groups). The $𝐆^F$-endomorphism algebra of an Harish-Chandra induced $R_{𝐋^F}^{𝐆^F}λ$, where $λ$ is a cuspidal unipotent character turns out to be a Hecke algebra associated to the group $W_{𝐆^F}(𝐋^F):=N_{𝐆^F}(𝐋)/𝐋$, which turns out to be a Coxeter group. Thus another parameterization is by triples $(𝐋,λ,φ)$, where $λ$ is a cuspidal unipotent character of $𝐋^F$ and $φ$ is an irreducible character of the relative group $W_{𝐆^F}(𝐋^F)$. Such characters are said to belong to the Harish-Chandra series determined by $(𝐋,λ)$.

A final piece of information attached to unipotent characters is the eigenvalues of Frobenius. Let $Fᵟ$ be the smallest power of the isogeny $F$ which is a split Frobenius (that is, $Fᵟ$ is a Frobenius and $φᵟ=1$). Then $Fᵟ$ acts naturally on Deligne-Lusztig varieties and thus on the corresponding virtual modules, and commutes to the action of $𝐆^F$; thus for a given unipotent character $ρ$, a submodule of the virtual module which affords $ρ$ affords a single eigenvalue $μ$ of $Fᵟ$. Results of Lusztig and Digne-Michel show that this eigenvalue is of the form $qᵃᵟλᵨ$ where $2a∈ℤ$ and $λᵨ$ is a root of unity which depends only on $ρ$ and not the considered module. This $λᵨ$ is called the eigenvalue of Frobenius attached to $ρ$. Unipotent characters in the Harish-Chandra series of a pair $(𝐋,λ)$ have the same eigenvalue of Frobenius as $λ$.

This package contains tables of all this information, and can compute Harish-Chandra and Lusztig induction of unipotent characters and almost characters. We illustrate this on some examples:

julia> W=coxgroup(:G,2)
G₂

julia> uc=UnipotentCharacters(W)
UnipotentCharacters(G₂)
┌───────┬────────────────────────────────────────────────────┐
│γ      │n₀    Deg(γ)  Feg              Symbol Fr(γ)    label│
├───────┼────────────────────────────────────────────────────┤
│φ₁‚₀   │ 1         1    1       (0,0,0,0,0,2)     1         │
│φ₁‚₆   │ 2        q⁶   q⁶ (01,01,01,01,01,12)     1         │
│φ′₁‚₃  │ 3   qΦ₃Φ₆/3   q³            (0,0,1+)     1    (1,ρ)│
│φ″₁‚₃  │ 4   qΦ₃Φ₆/3   q³            (0,0,1-)     1   (g₃,1)│
│φ₂‚₁   │ 5  qΦ₂²Φ₃/6  qΦ₈       (0,0,0,0,1,1)     1    (1,1)│
│φ₂‚₂   │ 6  qΦ₂²Φ₆/2 q²Φ₄       (0,0,0,1,0,1)     1   (g₂,1)│
│G₂[-1] │ 7  qΦ₁²Φ₃/2    0       (01,0,01,,0,)    -1   (g₂,ε)│
│G₂[1]  │ 8  qΦ₁²Φ₆/6    0       (01,01,0,,,0)     1    (1,ε)│
│G₂[ζ₃] │ 9 qΦ₁²Φ₂²/3    0       (01,0,0,01,,)    ζ₃  (g₃,ζ₃)│
│G₂[ζ₃²]│10 qΦ₁²Φ₂²/3    0       (01,01,,0,0,)   ζ₃² (g₃,ζ₃²)│
└───────┴────────────────────────────────────────────────────┘

The first column gives the name of the unipotent character, derived from its Harish-Chandra classification; the first 6 characters are in the principal series so are named by characters of W. The last 4 are cuspidal, and named by the corresponding eigenvalue of Frobenius, which is displayed in the fourth column. For classical groups, the Harish-Chandra data can be synthesized combinatorially to give a symbol.

The first two characters are each in a Lusztig family by themselves. The last eight are in a family associated to the group Γ=𝔖₃: the last column shows the parameters (x,θ). The third column shows the degree of the unipotent characters, which is transformed by the Lusztig Fourier matrix of the third column, which gives the degree of the corresponding almost character, or equivalently the fake degree of the corresponding character of W (extended by 0 outside the principal series).

One can get more information on the Lusztig Fourier matrix of the big family by asking

julia> uc.families[1]
Family(D(𝔖 ₃),[5, 6, 4, 3, 8, 7, 9, 10])
Drinfeld double of 𝔖 ₃, Lusztig′s version
┌────────┬────────────────────────────────────────────────────┐
│label   │eigen                                               │
├────────┼────────────────────────────────────────────────────┤
│(1,1)   │    1 1//6  1//2  1//3  1//3  1//6  1//2  1//3  1//3│
│(g₂,1)  │    1 1//2  1//2     .     . -1//2 -1//2     .     .│
│(g₃,1)  │    1 1//3     .  2//3 -1//3  1//3     . -1//3 -1//3│
│(1,ρ)   │    1 1//3     . -1//3  2//3  1//3     . -1//3 -1//3│
│(1,ε)   │    1 1//6 -1//2  1//3  1//3  1//6 -1//2  1//3  1//3│
│(g₂,ε)  │   -1 1//2 -1//2     .     . -1//2  1//2     .     .│
│(g₃,ζ₃) │   ζ₃ 1//3     . -1//3 -1//3  1//3     .  2//3 -1//3│
│(g₃,ζ₃²)│  ζ₃² 1//3     . -1//3 -1//3  1//3     . -1//3  2//3│
└────────┴────────────────────────────────────────────────────┘

One can do computations with individual unipotent characters. Here we construct the Coxeter torus, and then the identity character of this torus as a unipotent character.

julia> W=coxgroup(:G,2)
G₂

julia> T=spets(reflection_subgroup(W,Int[]),W(1,2))
G₂₍₎=Φ₆

julia> u=unipotent_character(T,1)
[G₂₍₎=Φ₆]:<Id>

To construct T one could equivalently do

julia> T=torus(W,position_class(W,W(1,2)))
G₂₍₎=Φ₆

Then here are two ways to construct the Deligne-Lusztig character associated to the Coxeter torus:

julia> lusztig_induce(W,u)
[G₂]:<φ₁‚₀>+<φ₁‚₆>-<φ₂‚₁>+<G₂[-1]>+<G₂[ζ₃]>+<G₂[ζ₃²]>

julia> v=deligne_lusztig_character(W,[1,2])
[G₂]:<φ₁‚₀>+<φ₁‚₆>-<φ₂‚₁>+<G₂[-1]>+<G₂[ζ₃]>+<G₂[ζ₃²]>

julia> degree(v)
Pol{Int64}: q⁶+q⁵-q⁴-2q³-q²+q+1

julia> v*v
6

The last two lines ask for the degree of v, then for the scalar product of v with itself.

Finally we mention that Chevie can also provide unipotent characters of Spetses, as defined in BroueMalleMichel2014. An example:

julia> UnipotentCharacters(complex_reflection_group(4))
UnipotentCharacters(G₄)
┌─────┬────────────────────────────────────────┐
│γ    │n₀            Deg(γ)    Feg Fr(γ)  label│
├─────┼────────────────────────────────────────┤
│φ₁‚₀ │ 1                 1      1     1       │
│φ₁‚₄ │ 2  -√-3q⁴Φ″₃Φ₄Φ″₆/6     q⁴     1   1∧ζ₆│
│φ₁‚₈ │ 3   √-3q⁴Φ′₃Φ₄Φ′₆/6     q⁸     1 -1∧ζ₃²│
│φ₂‚₅ │ 4         q⁴Φ₂²Φ₆/2   q⁵Φ₄     1  1∧ζ₃²│
│φ₂‚₃ │ 5 -ζ₃√-3qΦ″₃Φ₄Φ′₆/3   q³Φ₄     1  1∧ζ₃²│
│φ₂‚₁ │ 6 ζ₃²√-3qΦ′₃Φ₄Φ″₆/3    qΦ₄     1   1∧ζ₃│
│φ₃‚₂ │ 7            q²Φ₃Φ₆ q²Φ₃Φ₆     1       │
│Z₃:2 │ 8     -√-3qΦ₁Φ₂Φ₄/3      0   ζ₃² ζ₃∧ζ₃²│
│Z₃:11│ 9    -√-3q⁴Φ₁Φ₂Φ₄/3      0   ζ₃² ζ₃∧ζ₆⁵│
│G₄   │10        -q⁴Φ₁²Φ₃/2      0    -1  ζ₆∧-1│
└─────┴────────────────────────────────────────┘

UnipotentCharacters(W)

W should be a Coxeter group, a Coxeter Coset or a Spetses. The function gives back a record containing information about the unipotent characters of the associated algebraic group (or Spetses). This contains the following fields:

.harishChandra: information about Harish-Chandra series of unipotent characters. This is itself a list of records, one for each pair (𝐋,λ) of a Levi of an F-stable parabolic subgroup and a cuspidal unipotent character of $𝐋^F$. These records themselves have the following fields:

:levi: a list 'l' such that 𝐋 corresponds to 'ReflectionSubgroup(W,l)'.

:cuspidalName: the name of the unipotent cuspidal character lambda.

:eigenvalue: the eigenvalue of Frobenius for λ.

:relativeType: the reflection type of $W_𝐆 (𝐋)$;

:parameterExponents: the $𝐆 ^F$-endomorphism algebra of $R_𝐋^𝐆 (λ)$ is a Hecke algebra for $W_𝐆 (𝐋)$ with some parameters of the form $q^{a_s}$. This holds the list of exponents $a_s$.

:charNumbers: the indices of the unipotent characters indexed by the irreducible characters of $W_𝐆 (𝐋)$.

.almostHarishChandra: information about Harish-Chandra series of unipotent character sheaves. This is identical to ̀harishChandra` for a split reductive group, and reflects the situation for the corresponding split group for a nonsplit group.

.families: information about Lusztig families of unipotent characters. This is itself a list of records, one for each family. These records are described in the section about families below.

the following information is computed on demand from uc=UnipotentCharacters(W):

spets(uc): the reductive group W.

julia> W=coxgroup(:Bsym,2)
Bsym₂

julia> WF=spets(W,Perm(1,2))
²Bsym₂

julia> uc=UnipotentCharacters(WF)
UnipotentCharacters(²Bsym₂)
┌────────┬─────────────────────────────────────────────────────┐
│γ       │n₀ almostch    Deg(γ)   Feg        Symbol Fr(γ) label│
├────────┼─────────────────────────────────────────────────────┤
│2       │ 1       2.         1     1     (02,,0,0)     1      │
│11      │ 2      .11        q⁴    q⁴ (012,1,01,01)     1      │
│²B₂[1,3]│ 3      1.1 √2qΦ₁Φ₂/2 qΦ₁Φ₂     (01,,1,0)   ζ₈³     1│
│²B₂[1,5]│ 4       B₂ √2qΦ₁Φ₂/2     0     (01,,0,1)   ζ₈⁵     2│
└────────┴─────────────────────────────────────────────────────┘

julia> uc.families
3-element Vector{Family}:
 Family(C₁,[1])
 Family(C₁,[2])
 Family(?4,[3, 4])

julia> uc.families[3]
Family(?4,[3, 4])
┌─────┬────────────────┐
│label│eigen    1     2│
├─────┼────────────────┤
│1    │  ζ₈³ √2/2 -√2/2│
│2    │  -ζ₈ √2/2  √2/2│
└─────┴────────────────┘

charnames(uc): the list of names of the unipotent characters. Using appropriate keywords, one can control the display in various ways.

julia> uc=UnipotentCharacters(coxgroup(:G,2));

julia> charnames(uc;limit=true)
10-element Vector{String}:
 "φ₁‚₀"
 "φ₁‚₆"
 "φ′₁‚₃"
 "φ″₁‚₃"
 "φ₂‚₁"
 "φ₂‚₂"
 "G₂[-1]"
 "G₂[1]"
 "G₂[ζ₃]"
 "G₂[ζ₃²]"

julia> charnames(uc;TeX=true)
10-element Vector{String}:
 "\phi_{1,0}"
 "\phi_{1,6}"
 "\phi_{1,3}'"
 "\phi_{1,3}''"
 "\phi_{2,1}"
 "\phi_{2,2}"
 "G_2[-1]"
 "G_2[1]"
 "G_2[\zeta_3]"
 "G_2[\zeta_3^2]"

One can control the display of unipotent characters in various ways by IOContext properties. In the display, the row labels are the names of the unipotent characters. The possible columns are numbered as follows:

1. The index of the character in the list of unipotent characters.
2. The degree of the unipotent character.
3. The degree of the corresponding almost character.
4. for imprimitive groups, the symbol attached to the unipotent character.
5. The eigenvalue of Frobenius attached to the unipotent character.
6. The parameter the character has in its Lusztig family.

Which columns are displayed can be controlled by the property :cols (default [2,3,5,6] and 4 when applicable).

In addition if ':byfamily=true', the characters are displayed family by family instead of in index order. Finally, the properties rows and columnrepartition of format can be set, giving more tuning of the table.

julia> W=coxgroup(:B,2)
B₂

julia> uc=UnipotentCharacters(W)
UnipotentCharacters(B₂)
┌───┬──────────────────────────────────┐
│γ  │n₀ Deg(γ) Feg   Symbol Fr(γ) label│
├───┼──────────────────────────────────┤
│11.│ 1  qΦ₄/2  q²   (12,0)     1   +,-│
│1.1│ 2 qΦ₂²/2 qΦ₄   (02,1)     1   +,+│
│.11│ 3     q⁴  q⁴ (012,12)     1      │
│2. │ 4      1   1     (2,)     1      │
│.2 │ 5  qΦ₄/2  q²   (01,2)     1   -,+│
│B₂ │ 6 qΦ₁²/2   0   (012,)    -1   -,-│
└───┴──────────────────────────────────┘

julia> xdisplay(uc;byfamily=true)
┌────┬──────────────────────────────────┐
│γ   │n₀ Deg(γ) Feg   Symbol Fr(γ) label│
├────┼──────────────────────────────────┤
│11. │ 1  qΦ₄/2  q²   (12,0)     1   +,-│
│1.1ˢ│ 2 qΦ₂²/2 qΦ₄   (02,1)     1   +,+│
│.2  │ 5  qΦ₄/2  q²   (01,2)     1   -,+│
│B₂  │ 6 qΦ₁²/2   0   (012,)    -1   -,-│
├────┼──────────────────────────────────┤
│2.  │ 4      1   1     (2,)     1      │
├────┼──────────────────────────────────┤
│.11 │ 3     q⁴  q⁴ (012,12)     1      │
└────┴──────────────────────────────────┘

julia> xdisplay(uc;cols=[1,4])
UnipotentCharacters(B₂)
┌───┬───────────┐
│γ  │n₀   Symbol│
├───┼───────────┤
│11.│ 1   (12,0)│
│1.1│ 2   (02,1)│
│.11│ 3 (012,12)│
│2. │ 4     (2,)│
│.2 │ 5   (01,2)│
│B₂ │ 6   (012,)│
└───┴───────────┘

Base.show(io::IO,w::UniChar)

The formatting of unipotent characters is affected by IO property :compact . If true (the default) they are printed in a compact form. Otherwise, they are printed one unipotent character per line:

julia> xdisplay(w;compact=false)
[G₂]:
<φ₁‚₀>    1
<φ₁‚₆>    0
<φ′₁‚₃>   0
<φ″₁‚₃>   -1
<φ₂‚₁>    0
<φ₂‚₂>    0
<G₂[-1]>  2
<G₂[1]>   0
<G₂[ζ₃]>  0
<G₂[ζ₃²]> 1

charnames(uc;options...) charnames(io::IO,uc)

returns the list of character names for the unipotent characters uc. The optional options are IOContext attributes which can give alternative names in certain cases, or a different formatting of names in general. They can be specified by giving an IO as argument.

degrees(uc::UnipotentCharacters,q=Pol())

Returns the list of degrees of the unipotent characters of the finite reductive group (or Spetses) with Weyl group (or Spetsial reflection group) W, evaluated at q.

julia> W=coxgroup(:G,2)
G₂

julia> uc=UnipotentCharacters(W);

julia> degrees(uc)
10-element Vector{Pol{Rational{Int64}}}:
 1
 q⁶
 (1//3)q⁵+(1//3)q³+(1//3)q
 (1//3)q⁵+(1//3)q³+(1//3)q
 (1//6)q⁵+(1//2)q⁴+(2//3)q³+(1//2)q²+(1//6)q
 (1//2)q⁵+(1//2)q⁴+(1//2)q²+(1//2)q
 (1//2)q⁵+(-1//2)q⁴+(-1//2)q²+(1//2)q
 (1//6)q⁵+(-1//2)q⁴+(2//3)q³+(-1//2)q²+(1//6)q
 (1//3)q⁵+(-2//3)q³+(1//3)q
 (1//3)q⁵+(-2//3)q³+(1//3)q

fourier(uc::UnipotentCharacters) the Lusztig Fourier matrix for uc.

CycPoldegrees(uc::UnipotentCharacters)

Taking advantage that the degrees of unipotent characters of the finite reductive group (or Spetses) with Weyl group (or Spetsial reflection group) W are products of cyclotomic polynomials, this function returns these degrees as a list of CycPols. It is faster than CycPol.(degrees(uc)).

julia> W=coxgroup(:G,2)
G₂

julia> CycPoldegrees(UnipotentCharacters(W))
10-element Vector{CycPol{Rational{Int64}}}:
 1
 q⁶
 qΦ₃Φ₆/3
 qΦ₃Φ₆/3
 qΦ₂²Φ₃/6
 qΦ₂²Φ₆/2
 qΦ₁²Φ₃/2
 qΦ₁²Φ₆/6
 qΦ₁²Φ₂²/3
 qΦ₁²Φ₂²/3

fix illegal relativeTypes B1 and C2 which appear in HC or almost HC series of classical groups

almost_character(W,i) or almostchar(W,i)

This function returns the i-th almost unipotent character of the algebraic group 𝐆 associated to the Coxeter group or Coxeter coset W. If φ is the i-th irreducible character of W, the i-th almost character is $R_φ=W⁻¹∑_{w∈ W} φ(w) R_{𝐓_w}^𝐆 (1)$ where $𝐓_w$ is the maximal torus associated to the conjugacy class (or ϕ-conjugacy class for a coset) of w.

julia> W=coxgroup(:B,2)
B₂

julia> almostchar(W,3)
[B₂]:<.11>

julia> almostchar(W,1)
[B₂]:1//2<11.>+1//2<1.1>-1//2<.2>-1//2<B₂>

cuspidal(uc::UnipotentCharacters[,e])

A unipotent character γ of a finite reductive group 𝐆 is e-cuspidal if its Lusztig restriction to any proper e-split Levi is zero. When e==1 (the default when e is omitted) we recover the usual notion of cuspidal character. Equivalently the Φₑ-part of the generic degree of γ is equal to the Φₑ-part of the generic order of the adjoint group of 𝐆. This makes sense for any Spetsial complex reflection group and is implemented for them.

The function returns the list of indices of unipotent characters which are e-cuspidal.

julia> W=coxgroup(:D,4)
D₄

julia> cuspidal(UnipotentCharacters(W))
1-element Vector{Int64}:
 14

julia> cuspidal(UnipotentCharacters(W),6)
8-element Vector{Int64}:
  1
  2
  6
  7
  8
  9
 10
 12

julia> cuspidal(UnipotentCharacters(complex_reflection_group(4)),3)
4-element Vector{Int64}:
  3
  6
  7
 10

cuspidal_data(W[,d[,ad]];proper=false,all=false)

returns named tuples (levi=LF,cuspidal=λ,d=d) where LF is a d-split Levi (with d-center of dimension ad if ad is given) and λ is a d-cuspidal character of LF. If d=1 this returns ordinary cuspidal characters. The character λ is given as its index in the list of unipotent characters. If d was given as an integer, it is returned as a Root1 representing E(d).

If the keyword proper=true is given, only the data where LF!=W (or equivalently ad>0) are returned.

If d is omitted, data for all d orders of eigenvalues of elements of W is returned. If in addition the keyword argument all=true is given, data for all eigenvalues of elements of W is returned.

julia> cuspidal_data(coxgroup(:F,4),1)
9-element Vector{@NamedTuple{levi::Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}, cuspidal::Int64, d::Root1}}:
 (levi = F₄, cuspidal = 31, d = 1)
 (levi = F₄, cuspidal = 32, d = 1)
 (levi = F₄, cuspidal = 33, d = 1)
 (levi = F₄, cuspidal = 34, d = 1)
 (levi = F₄, cuspidal = 35, d = 1)
 (levi = F₄, cuspidal = 36, d = 1)
 (levi = F₄, cuspidal = 37, d = 1)
 (levi = F₄₍₃₂₎=B₂₍₂₁₎Φ₁², cuspidal = 6, d = 1)
 (levi = F₄₍₎=Φ₁⁴, cuspidal = 1, d = 1)

julia> cuspidal_data(complex_reflection_group(4),3)
5-element Vector{@NamedTuple{levi::Spets{PRSG{Cyc{Rational{Int64}}, Int16}}, cuspidal::Int64, d::Root1}}:
 (levi = G₄, cuspidal = 3, d = ζ₃)
 (levi = G₄, cuspidal = 6, d = ζ₃)
 (levi = G₄, cuspidal = 7, d = ζ₃)
 (levi = G₄, cuspidal = 10, d = ζ₃)
 (levi = G₄₍₎=Φ₁Φ′₃, cuspidal = 1, d = ζ₃)

deligne_lusztigCharTable(W) or dlCharTable(W)

for each conjugacy class of W, gives the decomposition of R_{T_w}^G in unipotent characters.

julia> dlCharTable(W)
6×10 Matrix{Int64}:
 1   1   1   1   2   2   0   0   0   0
 1  -1   1  -1   0   0   0   0   0   0
 1  -1  -1   1   0   0   0   0   0   0
 1   1   0   0  -1   0   1   0   1   1
 1   1   0   0   0  -1   0   1  -1  -1
 1   1  -1  -1   0   0  -2  -2   0   0

deligne_lusztig_character(W,w) or dlchar(W,w)

This function returns the Deligne-Lusztig character $R_𝐓 ^𝐆 (1)$ of the algebraic group 𝐆 associated to the Coxeter group or Coxeter coset W. The torus 𝐓 can be specified in 3 ways: if w is an integer, it represents the w-th conjugacy class (or phi-conjugacy class for a coset Wϕ) of W. Otherwise w can be a word or an element of W, and it represents the class (or ϕ-class) of w.

julia> W=coxgroup(:G,2)
G₂

julia> dlchar(W,3)
[G₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>

julia> dlchar(W,W(1))
[G₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>

julia> dlchar(W,[1])
[G₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>

julia> dlchar(W,[1,2])
[G₂]:<φ₁‚₀>+<φ₁‚₆>-<φ₂‚₁>+<G₂[-1]>+<G₂[ζ₃]>+<G₂[ζ₃²]>

deligne_lusztig_lefschetz(h,m=0) or dllefschetz(h,m=0)

Here h is an element of a Hecke algebra associated to a Coxeter group W or Coxeter coset Wϕ which itself is associated to an algebraic group 𝐆. By DigneMichel1985, for $g∈ 𝐆^F$, the number of fixed points of Fᵐ on the Deligne-Lusztig variety associated to the element wϕ∈Wϕ, have for m divisible by a sufficently large integer d, the form $∑_φ φ_{(qᵐ)}(T_wϕ)R_φ(g)$ where φ runs over the irreducible characters of $Wϕ$, where $R_φ$ is the corresponding almost character, and where $φ_{(qᵐ)}$ is a character value of the Hecke algebra $H(Wϕ,qᵐ)$ of $Wϕ$ with parameter qᵐ. This expression is called the Lefschetz character of the Deligne-Lusztig variety. If we consider qᵐ as an indeterminate x, it can be seen as a sum of unipotent characters with coefficients character values of the generic Hecke algebra $H(Wϕ,x)$. A more complicated formula involving the eigenvalues of Frobenius attached to unipotent characters applies for m not prime to d. The function returns this formula when a second parameter m≠0 is given.

The function 'dllefschetz' takes as argument a Hecke element and returns the corresponding Lefschetz character. This is defined on the whole of the Hecke algebra by linearity. The Lefschetz character of various varieties related to Deligne-Lusztig varieties, like their completions or desingularisation, can be obtained by taking the Lefschetz character at various elements of the Hecke algebra.

julia> W=coxgroup(:A,2)
A₂

julia> H=hecke(W,Pol(:q))
hecke(A₂,q)

julia> T=Tbasis(H);

julia> dllefschetz(T(1,2))
[A₂]:<111>-q<21>+q²<3>

julia> dllefschetz((T(1)+T())*(T(2)+T()))
[A₂]:q<21>+(q²+2q+1)<3>

The last line shows the Lefschetz character of the Samelson-Bott desingularisation of the Coxeter element Deligne-Lusztig variety.

We now show an example with a coset (corresponding to the unitary group).

julia> H=hecke(spets(W,Perm(1,2)),Pol(:q)^2)
hecke(²A₂,q²)

julia> T=Tbasis(H);dllefschetz(T(1))
[²A₂]:-<11>-q<²A₂>+q²<2>

Finally, there is a second form dllefschetz(H::HeckeAlgebra,w,i=0) where the arguments are a Hecke algebra and an element of w. This may be used for Spetses where we know the column of the CharTable of H for w but not other columns of the spetsial Hecke algebra charcater table.

lusztig_induce(W,u)

u should be a unipotent character of a parabolic subcoset of the Coxeter coset W. It represents a unipotent character λ of a Levi 𝐋 of the algebraic group 𝐆 attached to W. The program returns the Lusztig induced $R_𝐋^𝐆(λ)$.

julia> W=coxgroup(:G,2)
G₂

julia> WF=spets(W)
G₂

julia> T=subspets(WF,Int[],W(1))
G₂₍₎=Φ₁Φ₂

julia> u=unichar(T,1)
[G₂₍₎=Φ₁Φ₂]:<Id>

julia> lusztig_induce(WF,u)
[G₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>

julia> dlchar(W,W(1))
[G₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>

lusztig_restrict(R,u)

u should be a unipotent character of a parent Coxeter coset W of which R is a parabolic subcoset. It represents a unipotent character γ of the algebraic group 𝐆 attached to W, while R represents a Levi subgroup L. The program returns the Lusztig restriction $*R_𝐋^𝐆(γ)$.

julia> W=coxgroup(:G,2)
G₂

julia> WF=spets(W)
G₂

julia> T=subspets(WF,Int[],W(1))
G₂₍₎=Φ₁Φ₂

julia> u=dlchar(W,W(1))
[G₂]:<φ₁‚₀>-<φ₁‚₆>-<φ′₁‚₃>+<φ″₁‚₃>

julia> lusztig_restrict(T,u)
[G₂₍₎=Φ₁Φ₂]:4<Id>

julia> T=subspets(WF,Int[],W(2))
G₂₍₎=Φ₁Φ₂

julia> lusztig_restrict(T,u)
[G₂₍₎=Φ₁Φ₂]:0

on_unipotents(W,aut)

W is a reflection group or reflection coset representing a finite reductive group $𝐆 ^F$, and aut is an automorphism of $𝐆 ^F$ (for W a permutation group, this can be given as a permutation of the roots). The function returns the permutation of the unipotent characters of $𝐆 ^F$ induced by aut. This makes sense for Spetsial complex reflection groups and is implemented for them.

julia> WF=rootdatum("3D4")
³D₄

julia> on_unipotents(Group(WF),WF.phi)
(1,7,2)(8,12,9)

unipotent_character(W,l) or unichar(W,l)

Constructs an object representing the unipotent character specified by l of the algebraic group associated to the Coxeter group or Coxeter coset specified by W. There are 3 possibilities for l: if it is an integer, the l-th unipotent character of W is returned. If it is a string, the unipotent character of W whose name is l is returned (where the names are as given by charnames(UnipotentCharacters(W))). Finally, l can be a list of length the number of unipotent characters of W, which specifies the coefficient to give to each unipotent character.

julia> W=coxgroup(:G,2)
G₂

julia> u=unichar(W,7)
[G₂]:<G₂[-1]>

julia> v=unichar(W,"G2[E3]")
[G₂]:<G₂[ζ₃]>

julia> w=unichar(W,[1,0,0,-1,0,0,2,0,0,1])
[G₂]:<φ₁‚₀>-<φ″₁‚₃>+2<G₂[-1]>+<G₂[ζ₃²]>

julia> unichar(W,fourier(UnipotentCharacters(W))[3,:])
[G₂]:2//3<φ′₁‚₃>-1//3<φ″₁‚₃>+1//3<φ₂‚₁>+1//3<G₂[1]>-1//3<G₂[ζ₃]>-1//3<G₂[ζ₃²]>

The last line shows the almost character associated to the 3rd unipotent character of W.

some limited arithmetic is available on unipotent characters:

julia> coefficients(u) # so that u==unichar(W,coefficients(u))
10-element Vector{Int64}:
 0
 0
 0
 0
 0
 0
 1
 0
 0
 0

julia> w-2u
[G₂]:<φ₁‚₀>-<φ″₁‚₃>+<G₂[ζ₃²]>

julia> w*w  # scalar product
7

julia> degree(w)
Pol{Int64}: q⁵-q⁴-q³-q²+q+1

CycPol(x::Mvp) converts univariate Mvp x to a CycPol

eigmat(m::Matrix) eigenvalues of finite order of m, as a Vector{Root1}

blocks(G::Group,p::Integer)

Let p be a prime. This function returns the partition of the irreducible characters of G in p-blocks, represented by the list of indices of irreducibles characters in each block.

julia> W=coxsym(5)
𝔖 ₅

julia> blocks(W,2)
2-element Vector{Vector{Int64}}:
 [1, 3, 4, 5, 7]
 [2, 6]

julia> blocks(W,3)
3-element Vector{Vector{Int64}}:
 [1, 5, 6]
 [2, 3, 7]
 [4]

julia> blocks(W,7)
7-element Vector{Vector{Int64}}:
 [1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]

factor(p::Mvp)

p should be of degree <=2 thus represent a quadratic form. The function returns a list of two linear forms of which p is the product if such forms exist, otherwise it returns [p].

julia> @Mvp x,y

julia> factor(x^2-y^2+x+3y-2)
2-element Vector{Mvp{Int64, Int64}}:
 x-y+2
 x+y-1

julia> factor(x^2+x+1)
2-element Vector{Mvp{Cyc{Int64}, Int64}}:
 x-ζ₃
 x-ζ₃²

julia> factor(x*y-1)
1-element Vector{Mvp{Int64, Int64}}:
 xy-1

FindSeriesInParent(h,HF,WF,ww)

find series h of levi HF in WF (ww is uw.harish or uw.almostHarish) returns a namedtuple with 2 fields: ser= series found op: an element of W conjugating h.levi to ser.levi (not needed for Coxeter groups and standard levis H)

lusztig_induction_table(R,W)

R should be a parabolic subgroup of the Coxeter group W or a parabolic subcoset of the Coxeter coset W, in each case representing a Levi subgroup 𝐋 of the algebraic group 𝐆 associated to W. The function returns an InductionTable representing the Lusztig induction $R_𝐋^𝐆$ between unipotent characters.

julia> W=coxgroup(:B,3)
B₃

julia> t=twistings(W,[1,3])
2-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 B₃₍₁₃₎=Ã₁×A₁Φ₁
 B₃₍₁₃₎=Ã₁×A₁Φ₂

julia> lusztig_induction_table(t[2],W)
Lusztig induction from B₃₍₁₃₎=Ã₁×A₁Φ₂ to B₃
┌─────┬───────────────────────┐
│     │11⊗ 11 11⊗ 2 2⊗ 11 2⊗ 2│
├─────┼───────────────────────┤
│111. │     1    -1    -1    .│
│11.1 │    -1     .     1   -1│
│1.11 │     .     .    -1    .│
│.111 │    -1     .     .    .│
│21.  │     .     .     .    .│
│1.2  │     1    -1     .    1│
│2.1  │     .     1     .    .│
│.21  │     .     .     .    .│
│3.   │     .     .     .    1│
│.3   │     .     1     1   -1│
│B₂:2 │     .     .     1   -1│
│B₂:11│     1    -1     .    .│
└─────┴───────────────────────┘

The module GAPENV creates a GAP3-like environment by extending locally the base functions *, +, -, ^, isless, copy, //, inv, length to their GAP3 semantics and defining quite a few other GAP3 functions, then loads the Chevie database in that environment.

CycPol(v::AbstractVector)

This form is an compact way unsed in the Chevie library of specifying a CycPol with only positive multiplicities: v should be a vector. The first element is taken as the .coeff of the CycPol, the second as the .valuation. Subsequent elements are rationals i//d representing (q-E(d)^i) or are integers d representing Φ_d(q).

julia>Pol(:q);

julia> CycPol([3,-5,6,3//7])
3q⁻⁵Φ₆(q-ζ₇³)

This is a port of the GAP3 package Algebras by Cédric Bonnafé.

GroupAlgebra(G,T=Int) group algebra of G with coefficients T

'SolomonAlgebra(W,K)'

Let (W,S) be a finite Coxeter group. If w is an element of W, let R(w)={s ∈ S | l(ws) > l(w)}. If I is a subset of S, we set Y_I={w ∈ W | R(w)=I}, X_I={w ∈ W | R(w) ⊃ I}.

Note that X_I is the set of minimal length left coset representatives of W/W_I. Now, let y_I=∑_{w ∈ Y_I} w, x_I=∑_{w ∈ X_I} w.

They are elements of the group algebra ℤ W of W over Z. Now, let $Σ(W) = ⊕_{I ⊂ S} ℤ y_I = ⊕_{I ⊂ S} ℤ x_I$. This is a sub-ℤ-module of ℤW. In fact, Solomon proved that it is a sub-algebra of ℤW. Now, let K(W) be the Grothendieck ring of W and let θ:Σ(W)→ K(W) be the map defined by θ(x_I) = Ind_{W_I}^W 1. Solomon proved that this is an homomorphism of algebras. We call it the Solomon homomorphism.

returns the Solomon descent algebra of the finite Coxeter group (W,S) over K. If S=[s₁,…,sᵣ], the element x_I corresponding to the subset I=[s₁,s₂,s₄] of S is printed as |X(124)|. Note that 'A:=SolomonAlgebra(W,K)' is endowed with the following fields:

'A.W': the group W

'A.basis': the basis (x_I)_{I ⊂ S}.

'A.xbasis': the function sending the subset I (written as a number: for instance 124 for [s_1,s_2,s_4]) to x_I.

'A.ybasis': the function sending the subset I to y_I.

'A.injection': the injection of A in the group algebra of W, obtained by calling 'SolomonAlgebraOps.injection(A)'.

Note that 'SolomonAlgebra(W,K)' endows W with the field W.solomon which is a record containing the following fields:

'W.solomon_subsets': the set of subsets of S

'W.solomonconjugacy': conjugacy classes of parabolic subgroups of W (a conjugacy class is represented by the list of the positions, in 'W.solomon.subsets', of the subsets I of S such that `WI` lies in this conjugacy class).

'W.solomon_mackey': essentially the structure constants of the Solomon algebra over the rationals.

julia> W=coxgroup(:B,4)
B₄

julia> A=SolomonAlgebra(W)
SolomonAlgebra(B₄,Int64)

julia> X=A.xbasis; X(1,2,3)*X(2,4)
2X₂+2X₄

julia> W.solomon_subsets
16-element Vector{Vector{Int64}}:
 [1, 2, 3, 4]
 [1, 2, 3]
 [1, 2, 4]
 [1, 3, 4]
 [2, 3, 4]
 [1, 2]
 [1, 3]
 [1, 4]
 [2, 3]
 [2, 4]
 [3, 4]
 [1]
 [2]
 [3]
 [4]
 []

julia> W.solomon_conjugacy
12-element Vector{Vector{Int64}}:
 [1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7, 8]
 [9, 11]
 [10]
 [12]
 [13, 14, 15]
 [16]

julia> Algebras.injection(A)(X(1,2,3))
e_+e₄+e₃₄+e₂₃₄+e₁₂₃₄+e₂₁₂₃₄+e₃₂₁₂₃₄+e₄₃₂₁₂₃₄

ppart(g,p)

Given an element g of a group and an integer p we can uniquely write g=g₁g₂ where the order of g₂ is prime to p and the order of g₁ is a product of primes which divide p. this function returns g₁.

pprimesections(G::Group,p::Integer)

This function returns a partition of the indices of the conjugacy classes of G. Indices i,j are in the same part if the elements x/ppart(x,p) for x in classreps(G)[i],classreps(G)[j] are in the same class.

julia> G=symmetric_group(5)
Group((1,2),(2,3),(3,4),(4,5))

julia> Algebras.pprimesections(G,2)
3-element Vector{Vector{Int64}}:
 [1, 2, 4, 5]
 [3, 6]
 [7]

julia> Algebras.pprimesections(G,3)
5-element Vector{Vector{Int64}}:
 [1, 3]
 [2, 6]
 [4]
 [5]
 [7]

isabelian(A::FiniteDimAlgebra) whether A is commutative

Factoring polynomials over the rationals

LogInt(n::Integer,base::Integer)

returns floor(Int,log(base,n)) but very accurately. Assumes n>0 and base>1.

julia> Fact.LogInt(1024,2)
10

julia> Fact.LogInt(1,10)
0

factor(f::Pol{<:Union{Integer,Rational{<:Integer}}})

Factor f over the rationals. The result is a Primes.Factorization{typeof(f)}.

julia> factor(Pol(:q)^24-1)
(q-1) * (q²-q+1) * (q⁴-q²+1) * (q⁸-q⁴+1) * (q⁴+1) * (q²+1) * (q+1) * (q²+q+1)

Chevie contains some extended formatting facilities for printing, displaying, formatting objects in various ways. For that Chevie uses extensively IO properties. We have sevral convenience functions which make using IO properties easier.

rio(;d...) makes an IO stream which always has the property :limit=>true, to mimic the REPL default printing, and has also the extra properties given by the d... keywords. Using this, for instance

IOContext(stdout,:limit=>true,:compact=>true) becomes rio(compact=true).

We have versions of display functions which use implicitely rio:

xprint(x...;p...) is the same as print(rio(;p...),x...). Similarly for println, display we have xprintln, xdisplay.

xrepr(x;p...) is the same as repr(x;context=IOContext(stdout,p...)). xrepr(io,x) is the same as repr(x;context=io).

julia> @Pol q;p=(q^5+1)^2
Pol{Int64}: q¹⁰+2q⁵+1

julia> print(p)
Pol([1, 0, 0, 0, 0, 2, 0, 0, 0, 0, 1])
julia> xprint(p)
q¹⁰+2q⁵+1
julia> xprint(p;varname=:x)
x¹⁰+2x⁵+1
julia> repr(2E(5,2)+2E(5,3))
"Cyc{Int64}(-1-root(5))"

julia> xrepr(2E(5,2)+2E(5,3);quadratic=false)
"Cyc{Int64}(2E(5,2)+2E(5,3))"

Most objects in Chevie use TeX for printing when given the IO property :TeX=true. This is used as the default display in IJulia and Pluto by giving the property :TeX when defining Base.show(io::IO, ::MIME"text/html", ...) for these objects. Continuing the above example:

julia> xprint(p;TeX=true)
q^{10}+2q^5+1

A model we often adopt for displaying nicely complex objects is to first write a nice display using TeX output. This can be used directly in IJulia and Pluto. For other environments, we can compute from the TeX representation a suitable one using the following function:

fromTeX(io::IO,s) takes a TeX source and tries to give the best possible rendering on a given IO. This uses unicode characters at the REPL (if get(io,:limit,false)==true). In the worse case (stdout) all TeX special characters are stripped.

julia> s="E_6[\zeta_3]:\phi_{1,6}"
"E_6[\zeta_3]:\phi_{1,6}"

julia> fromTeX(rio(),s)
"E₆[ζ₃]:φ₁‚₆"

julia> fromTeX(stdout,s)
"E6[E3]:phi1,6"

printTeX(io,s) is the same as print(io,fromTeX(io,s)).

Other functions to ease formatting are described below: see showtable, joindigits, ordinal, cut.

cut(io::IO=stdout,string;width=displaysize(io)[2]-2,after=",",before="")

This function prints to io the string argument cut across several lines for improved display. It can take the following keyword arguments:

• width: the cutting width
• after: cut after these chars
• before: cut before these chars

julia> cut(string(collect(1:50)))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
 41, 42, 43, 44, 45, 46, 47, 48, 49, 50]

fromTeX to document

joindigits(l::AbstractVector{Int},delim="()";sep=",")

print a list l of (usually small) numbers as compactly as possible: no separators if all numbers are smaller than 10.

julia> joindigits([1,9,3,5])
"1935"

julia> joindigits([1,10,3,5])
"(1,10,3,5)"

julia> joindigits([1,10,3,5],"[]";sep="-")
"[1-10-3-5]"

ordinal(n::Integer)

string for an ordinal number respecting english syntax.

julia> ordinal(201)
"201st"

julia> ordinal(202)
"202nd"

julia> ordinal(203)
"203rd"

julia> ordinal(204)
"204th"

printTeX(io,s) is print(io,fromTeX(io,s))

rio(io::IO=stdout;p...) enriches io with the attributes in p. It always enriches with limit=true to mimic display at the REPL.

Thus print(rio(),x...) is like printing x... at the REPL.

showtable(io::IO=stdout, table::AbstractMatrix; keywords)

General routine to format a table at the REPL, or in IJulia or Pluto. The elements of table and any of the labels in the keywords can be of any type and are formatted in the context of io, excepted that a string s is formatted by fromTeX(io,s). The following options can be passed as properties of the io or as keywords.

• row_labels: labels for rows. A Vector{Any} (can be strings), default axes(table,1)
• rows_label: label for first column of row labels (default none)
• col_labels: labels for other columns (default none)
• align: a character in "lcr": alignment of columns (default 'r'); then all columns will be aligned as given except the rows_labels which will always be aligned left. Or if align is a string it should be of length 1+size(table,2) where the first character is the alignment of the row_labels.
• row_seps: line numbers after which to put a separator. A number of i means before i-th line of the table. So 0 is at the top of the table, -1 is before the col_labels. The default is [-1,0,size(table,1)].
• col_seps: column numbers after which to put a separator. A number of i means before i-th column of the table. So 0 is at the left of the table, -1 is before the row_labels. The default is [-1,0,size(table,2)]. Alternately the col_seps can be given using an align string in LaTeX style |r|llll|. They should be given by only one of the two ways.
• rows: show only these rows. Default all rows: axes(table,1)
• cols: show only these columns. Default all columns: axes(table,1)
• TeX: default false. If true, give LaTeX output (useful to give nicer output in Jupyter or Pluto)
• column_repartition: a Vector{<:Integer}. Display in vertical pieces of sizes indicated (useful for TeX: otherwise the column_repartition is automatically computed taking in account displaysize(io,2)).
• dotzero: if true replace a '0' by '.' in the table (default false).

julia> m=reshape(1:10:120,3,4)
3×4 reshape(::StepRange{Int64, Int64}, 3, 4) with eltype Int64:
  1  31  61   91
 11  41  71  101
 21  51  81  111

julia> showtable(m)
┌─┬────────────┐
│1│ 1 31 61  91│
│2│11 41 71 101│
│3│21 51 81 111│
└─┴────────────┘

julia> labels=["x","y","z","t"];

julia> showtable(m;cols=2:4,col_labels=labels,row_seps=[0,2,3])
    y  z   t 
┌─┬─────────┐
│1│31 61  91│
│2│41 71 101│
├─┼─────────┤
│3│51 81 111│
└─┴─────────┘

julia> showtable(m;col_labels=labels,rows_label="N",align="|r|ll|ll|")
┌─┬─────┬──────┐
│N│ x  y│ z   t│
├─┼─────┼──────┤
│1│1  31│61 91 │
│2│11 41│71 101│
│3│21 51│81 111│
└─┴─────┴──────┘

xdisplay(x...;p...) is like display but uses the enriched io rio(;p...)

xprint(x...;p...) is like print but uses the enriched io rio(;p...)

xprintln(x...;p...) is like println but uses the enriched io rio(;p...)

xrepr(x;p...) is repr using as context stdout enriched by p...

xrepr(io,x;p...) is repr using as context io enriched by p...

Algebraic groups and semi-simple elements

Let us fix an algebraically closed field K and let 𝐆 be a connected reductive algebraic group over K. Let 𝐓 be a maximal torus of 𝐆, let X(𝐓) be the character group of 𝐓 (resp. Y(𝐓) the dual lattice of one-parameter subgroups of 𝐓) and Φ (resp Φ^) the roots (resp. coroots) of 𝐆 with respect to 𝐓.

Then 𝐆 is determined up to isomorphism by the root datum (X(𝐓),Φ, Y(𝐓),Φ^). In algebraic terms, this consists in giving a free ℤ-lattice X=X(𝐓) of dimension the rank of 𝐓 (which is also called the rank of 𝐆), and a root system Φ ⊂ X, and similarly giving the dual roots Φ^⊂ Y=Y(𝐓).

This is obtained by a slight generalisation of our setup for a Coxeter group W. This time we assume that the canonical basis of the vector space V on which W acts is a ℤ-basis of X, and Φ is specified by a matrix simpleroots(W) whose rows are the simple roots expressed in this basis of X. Similarly Φ^ is described by a matrix simplecoroots(W) whose rows are the simple coroots in the basis of Y dual to the chosen basis of X. The duality pairing between X and Y is the canonical one, that is the pairing between vectors x∈ X and y∈ Y is given by transpose(x)*y. Thus, we must have the relation simplecoroots(W)*permutedims(simpleroots(W))=cartan(W).

We get this by using the function rootdatum, whose arguments are the two matrices simpleroots(W) and simplecoroots(W) described above. The roots need not generate V, so the matrices need not be square. For example, the root datum of the linear group of rank 3 can be obtained as:

julia> W=rootdatum([-1 1 0;0 -1 1],[-1 1 0;0 -1 1])
A₂Φ₁

julia> reflrep(W,W(1))
3×3 Matrix{Int64}:
 0  1  0
 1  0  0
 0  0  1

here the Weyl group is the symmetric group on 3 letters acting by permutation of the basis of X. The dimension of X, size(simpleroots(W),2), is the rank and the dimension of the subspace generated by the roots, size(simpleroots(W),1), is called the semi-simple rank. In the example the rank is 3 and the semisimple rank is

The default form W=coxgroup(:A,2) defines the adjoint algebraic group (the group in its isogeny class with a trivial centre). In this case Φ is a basis of X, so simpleroots(W) is the identity matrix and simplecoroots(W) is the Cartan matrix cartan(W) of the root system.

The form coxgroup(:A,2,sc=true) constructs the semisimple simply connected algebraic group, where simpleroots(W) is the transposed of cartan(W) and simplecoroots(W) is the identity matrix.

An extreme form of root data can be specified more conveniently: when W is the trivial coxgroup() (in this case 𝐆 is a torus), the root datum has no roots, thus is entirely determined by the rank r. The function torus(r) constructs such a root datum (it could be also obtained by giving two 0×r matrices to rootdatum).

Finally, the rootdatum function also understands some familiar names for the algebraic groups for which it gives the results that could be obtained by giving the appropriate simpleroots(W) and simplecoroots(W) matrices:

julia> rootdatum(:gl,3)   # same as the previous example
gl₃

The types of root data which are understood are :gl, :pgl, :sl, :slmod, :tgl :sp, :csp, :psp, :so, :pso, :cso, :halfspin, :gpin, :spin, :E6, :E6sc, :CE6, :E7, :E7sc, :CE7, :E8, :F4, :G2.

Semisimple elements

We construct semi-simple elements in two ways. The first way is for finite order elements of 𝐓, which over an algebraically closed field K are in bijection with elements of Y⊗ ℚ /ℤ whose denominator is prime to the characteristic of K. These are represented as a vector of Rationals r such that 0≤r<1. The function ss constructs such a semisimple element from a vector of Rationals.

More generally a torus 𝐓 over a field K is isomorphic to (Kˣ)^n where n is the dimension of 𝐓, so a vector of elements of Kˣ is a more general representation which is produced by the function SemisimpleElement; in this setting the result of ss is naturally interpreted as a Vector{Root1}, so it can also be obtained by calling SemisimpleElement which such a vector.

julia> G=rootdatum(:sl,4)
sl₄

julia> ss(G,[1//3,1//4,3//4,2//3])
SemisimpleElement{Root1}: <ζ₃,ζ₄,ζ₄³,ζ₃²>

julia> SemisimpleElement(G,[E(3),E(4),E(4,3),E(3,2)])
SemisimpleElement{Root1}: <ζ₃,ζ₄,ζ₄³,ζ₃²>

julia> L=reflection_subgroup(G,[1,3])
A₃₍₁₃₎=A₁×A₁Φ₁

julia> C=algebraic_center(L)
(Z0 = SubTorus(A₃₍₁₃₎=A₁×A₁Φ₁,[1 2 1]), AZ = Group(SemisimpleElement{Root1}[<1,1,-1>]), descAZ = [[1, 2]], ZD = Group(SemisimpleElement{Root1}[<-1,1,1>, <1,1,-1>]))

julia> T=torsion_subgroup(C.Z0,3)
Group(SemisimpleElement{Root1}[<ζ₃,ζ₃²,ζ₃>])

julia> e=sort(elements(T))
3-element Vector{SemisimpleElement{Root1}}:
 <1,1,1>
 <ζ₃,ζ₃²,ζ₃>
 <ζ₃²,ζ₃,ζ₃²>

In the above, the Levi subgroup L of SL₄ consisting of block-diagonal matrices of shape 2×2 is constructed. The function algebraic_center returns a named tuple with : the neutral component Z⁰ of the center Z of L, represented by a basis of Y(Z⁰), a complement subtorus S of 𝐓 to Z⁰ represented similarly by a basis of Y(S), and semi-simple elements representing the classes of Z modulo Z⁰ , chosen in S. The classes Z/Z⁰ also biject to the fundamental group as given by the field .descAZ, see algebraic_center for an explanation. Finally the semi-simple elements of order 3 in Z⁰ are computed.

julia> e[3]^G(2)
SemisimpleElement{Root1}: <ζ₃²,1,ζ₃²>

julia> orbit(G,e[3])
6-element Vector{SemisimpleElement{Root1}}:
 <ζ₃²,ζ₃,ζ₃²>
 <ζ₃²,1,ζ₃²>
 <ζ₃,1,ζ₃²>
 <ζ₃²,1,ζ₃>
 <ζ₃,1,ζ₃>
 <ζ₃,ζ₃²,ζ₃>

Here is the same computation as above performed with semisimple elements whose coefficients are in the finite field FF(4), representing elements of sl₄(𝔽₄).

julia> G=rootdatum(:sl,4)
sl₄

julia> s=SemisimpleElement(G,Z(4).^[1,2,1])
SemisimpleElement{FFE{2}}: <Z₄,Z₄²,Z₄>

julia> s^G(2)
SemisimpleElement{FFE{2}}: <Z₄,1,Z₄>

julia> orbit(G,s)
6-element Vector{SemisimpleElement{FFE{2}}}:
 <Z₄,Z₄²,Z₄>
 <Z₄,1,Z₄>
 <Z₄²,1,Z₄>
 <Z₄,1,Z₄²>
 <Z₄²,1,Z₄²>
 <Z₄²,Z₄,Z₄²>

We can compute the centralizer $C_𝐆 (s)$ of a semisimple element in 𝐆:

julia> G=coxgroup(:A,3)
A₃

julia> s=ss(G,[0,1//2,0])
SemisimpleElement{Root1}: <1,-1,1>

julia> centralizer(G,s)
A₃₍₁₃₎=(A₁A₁)Φ₂

The result is an ExtendedReflectionGroup; the reflection group part is the Weyl group of $C_𝐆 ⁰(s)$ and the extended part are representatives of $C_𝐆 (s)$ modulo $C_𝐆⁰(s)$ taken as diagram automorphisms of the reflection part. Here it is printed as a coset $C_𝐆 ⁰(s)ϕ$ which generates $C_𝐆 (s)$.

SubTorus(W,Y::Matrix{<:Integer})

The function returns the subtorus 𝐒 of the maximal torus 𝐓 of the reductive group represented by the Weyl group W such that Y(𝐒) is the (pure) sublattice of Y(𝐓) generated by the (integral) vectors Y. A basis of Y(𝐒) in Hermite normal form (for easy memebership testing) is computed and stored in the field S.gens of the returned SubTorus struct. A basis of Y(𝐓) adapted to Y(𝐒) is also computed. This means a set of integral vectors, stored in S.complement, is computed such that M=vcat(S.gens,S.complement) is a basis of Y(𝐓) (equivalently M∈GL(Z^{rank(W)}). An error is raised if Y does not define a pure sublattice.

julia> W=coxgroup(:A,4)
A₄

julia> SubTorus(W,[1 2 3 4;2 3 4 1;3 4 1 1])
SubTorus(A₄,[1 0 3 -13; 0 1 2 7; 0 0 4 -3])

julia> SubTorus(W,[1 2 3 4;2 3 4 1;3 4 1 2])
ERROR: not a pure sublattice
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] Chevie.Weyl.SubTorus(::FiniteCoxeterGroup{Perm{Int16},Int64}, ::Matrix{Int64}) at /home/jmichel/julia/Chevie.jl/src/Weyl.jl:1082
 [3] top-level scope at REPL[25]:1

A generalized Cartan matrix C is a square integer matrix of size n such that cᵢᵢ=2, cᵢⱼ≤0 if i≠j, and cᵢⱼ==0 if and only if cⱼᵢ==0. We say that C is indecomposable if it does not admit any block decomposition.

Let C be a generalized Cartan matrix. For I a subset of {1,…,n} we denote by C_I the square submatrix with indices i,j taken in I. If v is a real vector of length n, we write v>0 if for all i∈ {1,…,n} we have vᵢ>0. It can be shown that C is a Cartan matrix if and only if for all sets I, we have det C_I>0; or equivalently, if and only if there exists v>0 such that C.v>0. C is called an affine Cartan matrix if for all proper subsets I we have det C_I>0, but det C==0; or equivalently if there exists v>0 such that C.v==0.

Given an irreducible Weyl group W with Cartan matrix C, we can construct a generalized Cartan matrix C̃ as follows. Let α₀ be the opposed of the highest root. Then the matrix $\left(\begin{array}{cc}C&C.α₀\\ α₀.C&2\end{array}\right)$ is an affine Cartan matrix. The affine Cartan matrices which can be obtained in this way are those we are interested in, which give rise to affine Weyl groups.

Let d=n-rank(C). A realization of a generalized Cartan matrix is a pair V,Vᵛ of vector spaces of dimension n+d together with vectors α₁,…,αₙ∈ V (the simple roots), αᵛ₁,…,αᵛₙ∈ Vᵛ (the simple coroots), such that (αᵛᵢ, αⱼ)=c_{i,j}. Up to isomorphism, a realization is obtained as follows: write $C=\left(\begin{array}{c}C_1\\C_2\end{array}\right)$ where C₁ is of same rank as C. Then take αᵢ to be the first n vectors in a basis of V, and take αᵛⱼ to be given in the dual basis by the rows of the matrix $\left(\begin{array}{cc}C₁&0\\ C_2&\hbox{Id}_d\\ \end{array}\right).$ To C we associate a reflection group in the space V, generated by the fundamental reflections rᵢ given by rᵢ(v)=v-(αᵛᵢ,v)αᵢ. This is a Coxeter group, called the affine Weyl group ilde W associated to W when we start with the affine Cartan matrix associated to a Weyl group W.

The affine Weyl group is infinite; it has one additional generator s₀ (the reflection with respect to α₀) compared to W. We can not use 0 as a label by default for a generator of a Coxeter group (because the default labels are used as indices, and indices start at 1 in Julia) so we label it as n+1 where n is the numbers of generators of W.

julia> W=affine(coxgroup(:A,4))
Ã₄

julia> diagram(W)
       ————5————
      /         \
Ã₄   1———2———3———4

algebraic_center(W)

W should be a Weyl group, or an extended Weyl group. This function returns a description of the center Z of the algebraic group 𝐆 defined by W as a named tuple with the following fields:

Z0: the neutral component Z⁰ of Z as a subtorus of 𝐓.

AZ: representatives in Z of A(Z):=Z/Z⁰ given as a group of semisimple elements.

ZD: center of the derived subgroup of 𝐆 given as a group of semisimple elements.

descAZ: if W is not an extended Weyl group, describes A(Z) as a quotient of the center pi of the simply connected covering of 𝐆 (an incarnation of the fundamental group). It contains a list of elements given as words in the generators of pi which generate the kernel of the quotient map.

julia> G=rootdatum(:sl,4)
sl₄

julia> L=reflection_subgroup(G,[1,3])
A₃₍₁₃₎=A₁×A₁

ulia> C=algebraic_center(L)
(Z0 = SubTorus(A₃₍₁₃₎=A₁×A₁Φ₁,[1 2 1]), AZ = Group(SemisimpleElement{Root1}[<1,1,-1>]), descAZ = [[1, 2]], ZD = Group(SemisimpleElement{Root1}[<-1,1,1>, <1,1,-1>]))

julia> G=coxgroup(:A,3)
A₃

julia> s=ss(G,[0,1//2,0])
SemisimpleElement{Root1}: <1,-1,1>

julia> C=centralizer(G,s)
A₃₍₁₃₎=(A₁A₁)Φ₂

julia> algebraic_center(C)
(Z0 = SubTorus(A₃₍₁₃₎=A₁×A₁Φ₁,Matrix{Int64}(undef, 0, 3)), AZ = Group(SemisimpleElement{Root1}[<1,-1,1>]))

coweights(W) simple coweights in the basis of Y(T)

fundamental_group(W)

This function returns the fundamental group of the algebraic group defined by the Coxeter group struct W. This group is returned as a group of diagram automorphisms of the corresponding affine Weyl group, which is represented as a group of permutations of the set of simple roots enriched by the lowest root of each irreducible component. The definition we take of the fundamental group of a (not necessarily semisimple) reductive group is (P∩ Y(𝐓))/Q where P is the coweight lattice (the dual lattice in Y(𝐓)⊗ ℚ of the root lattice) and Q is the coroot latice. The bijection between elements of P/Q and diagram automorphisms is explained in the context of non-irreducible groups for example in §3.B Bonnafé2005.

julia> W=coxgroup(:A,3) # the adjoint group
A₃

julia> fundamental_group(W) # the 12th root is the lowest one
Group((1,12,3,2))

julia> W=rootdatum(:sl,4) # the semisimple simply connected group
sl₄

julia> fundamental_group(W)
Group(Perm{Int16}[])

intermediate_group(W, indices)

This computes a rootdatum representing a semisimple algebraic group intermediate between the adjoint group –- obtained by a call like rootdatum(:pgl,4)–- and the simply connected semi-simple group –- obtained by a call like rootdatum(:sl,4). The group is specified by specifying a subset of the minuscule weights, which are weights whose scalar product with every coroot is in -1,0,1 (the weights are the elements of the weight lattice, the lattice in X(𝐓)⊗ ℚ dual to the coroot lattice). The non-trivial characters of the (algebraic) center of a semi-simple simply connected algebraic group are in bijection with the minuscule weights; this set is also in bijection with P/Q where P is the weight lattice and Q is the root lattice. If W is irreducible, the minuscule weights are part of the basis of the weight lattice given by the fundamental weights, which is the dual basis of the simple coroots. They can thus be specified by an index in the Dynkin diagram. The constructed group has lattice X(𝐓) generated by the sum of the root lattice and the weights with the given indices. If W is not irreducible, a minuscule weight is a sum of minuscule weights in different components. An element of indices is thus itself a list, interpreted as representing the sum of the corresponding weights.

julia> W=coxgroup(:A,3)
A₃

julia> fundamental_group(intermediate_group(W,Int[])) # adjoint
Group((1,12,3,2))

julia> fundamental_group(intermediate_group(W,Int[2])) # intermediate
Group((1,3)(2,12))

quasi_isolated_reps(W,p=0)

W should be a Weyl group corresponding to an algebraic group 𝐆 over an algebraically closed field of characteristic 0. This function returns a list of semisimple elements for 𝐆, which are representatives of the 𝐆-orbits of quasi-isolated semisimple elements. It follows the algorithm given in Bonnafe2005. If a second argument p is given, it gives representatives of those quasi-isolated elements which exist in characteristic p.

julia> W=coxgroup(:E,6);l=quasi_isolated_reps(W)
5-element Vector{SemisimpleElement{Root1}}:
 <1,1,1,1,1,1>
 <1,-1,1,1,1,1>
 <1,1,1,ζ₃,1,1>
 <ζ₃,1,1,1,1,ζ₃>
 <1,ζ₆,ζ₆,1,ζ₆,1>

julia> map(s->isisolated(W,s),l)
5-element Vector{Bool}:
 1
 1
 1
 0
 0

julia> W=rootdatum(:E6sc);l=quasi_isolated_reps(W)
7-element Vector{SemisimpleElement{Root1}}:
 <1,1,1,1,1,1>
 <-1,1,1,-1,1,-1>
 <ζ₃,1,ζ₃²,1,ζ₃,ζ₃²>
 <ζ₃²,1,ζ₃,1,ζ₃,ζ₃²>
 <ζ₃²,1,ζ₃,1,ζ₃²,ζ₃>
 <ζ₆⁵,1,ζ₃²,1,ζ₃,ζ₃²>
 <ζ₃²,1,ζ₃,1,ζ₃²,ζ₆⁵>

julia> map(s->isisolated(W,s),l)
7-element Vector{Bool}:
 1
 1
 1
 1
 1
 1
 1

julia> Semisimple.quasi_isolated_reps(W,3)
2-element Vector{SemisimpleElement{Root1}}:
 <1,1,1,1,1,1>
 <-1,1,1,-1,1,-1>

semisimple_centralizer_representatives(W [,p]) or sscentralizer_reps

W should be a Weyl group corresponding to an algebraic group 𝐆. This function returns a list describing representatives 𝐇 of 𝐆-orbits of reductive subgroups of 𝐆 which are the identity component of the centralizer of a semisimple element. Each group 𝐇 is specified by a list h of reflection indices in W such that 𝐇 corresponds to reflection_subgroup(W,h). If a second argument p is given, only the list of the centralizers which occur in characteristic p is returned.

julia> W=coxgroup(:G,2)
G₂

julia> sscentralizer_reps(W)
6-element Vector{Vector{Int64}}:
 []
 [1]
 [2]
 [1, 2]
 [1, 5]
 [2, 6]

julia> reflection_subgroup.(Ref(W),sscentralizer_reps(W))
6-element Vector{FiniteCoxeterSubGroup{Perm{Int16},Int64}}:
 G₂₍₎=Φ₁²
 G₂₍₁₎=A₁Φ₁
 G₂₍₂₎=Ã₁Φ₁
 G₂
 G₂₍₁₅₎=A₂
 G₂₍₂₆₎=Ã₁×A₁

julia> sscentralizer_reps(W,2)
5-element Vector{Vector{Int64}}:
 []
 [1]
 [2]
 [1, 2]
 [1, 5]

structure_rational_points_connected_centre(W,q)

W should be a Coxeter group or a Coxeter coset representing a finite reductive group $𝐆 ^F$, and q should be the prime power associated to the isogeny F. The function returns the abelian invariants of the finite abelian group $Z⁰𝐆 ^F$ where Z⁰𝐆 is the connected center of 𝐆.

In the following example one determines the structure of 𝐓(𝔽₃) where 𝐓 runs over all the maximal tori of SL₄.

julia> l=twistings(rootdatum(:sl,4),Int[])
5-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 A₃₍₎=Φ₁³
 A₃₍₎=Φ₁²Φ₂
 A₃₍₎=Φ₁Φ₂²
 A₃₍₎=Φ₁Φ₃
 A₃₍₎=Φ₂Φ₄

julia> structure_rational_points_connected_centre.(l,3)
5-element Vector{Vector{Int64}}:
 [2, 2, 2]
 [2, 8]
 [4, 8]
 [26]
 [40]

torsion_subgroup(S::SubTorus,n)

This function returns the subgroup of semi-simple elements of order dividing n in the subtorus S.

julia> G=rootdatum(:sl,4)
sl₄

julia> L=reflection_subgroup(G,[1,3])
A₃₍₁₃₎=A₁×A₁Φ₁

julia> C=algebraic_center(L)
(Z0 = SubTorus(A₃₍₁₃₎=A₁×A₁Φ₁,[1 2 1]), AZ = Group(SemisimpleElement{Root1}[<1,1,-1>]), descAZ = [[1, 2]], ZD = Group(SemisimpleElement{Root1}[<-1,1,1>, <1,1,-1>]))

julia> T=torsion_subgroup(C.Z0,3)
Group(SemisimpleElement{Root1}[<ζ₃,ζ₃²,ζ₃>])

julia> sort(elements(T))
3-element Vector{SemisimpleElement{Root1}}:
 <1,1,1>
 <ζ₃,ζ₃²,ζ₃>
 <ζ₃²,ζ₃,ζ₃²>

weightinfo(W)

W is a Coxeter group record describing an algebraic group 𝐆, or a IypeIrred. The function is independent of the isogeny type of 𝐆(so just depends on refltype(W), that is on the root system). It returns a dict with the following keys:

• :minusculeWeights the minuscule weights, described as their position in the list of fundamental weights. For non-irreducible groups, a weight is the sum of at most one weight in each irreducible component. It is represented as the list of its components. For consistency, in the case of an irreducible system, a weight is represented as a one-element list.

• :minusculeCoweights the minuscule coweights, represented in the same manner as the minuscule weights

• :decompositions for each coweight, its decomposition in terms of the generators of the adjoint fundamental group (given by the list of the exponents of the generators). Together with the next field it enables to work out the group structure of the adjoint fundamental group.

• :moduli the list of orders of the generators of the fundamental group.

• :AdjointFundamentalGroup the list of generators of the adjoint fundamental group, given as permutations of the extended root basis.

• :CenterSimplyConnected A list of semisimple elements generating the center of the universal covering of 𝐆

• :chosenAdaptedBasis A basis of the weight lattice adapted to the root lattice. In the basis of the fundamental weights, the root lattice is given by C=transpose(cartan(W)). The property specifying the :chosenAdaptedBasis is that the Hermite normal form of C*chosenAdaptedBasis is almost in Smith normal form (it is diagonal but the diagonal entries may be permuted compared to the Smith normal form; the non-trivial entries are in the positions corresponding to the generators of the fundamental group as indicated by :decompositions).

julia> weightinfo(coxgroup(:A,2)*coxgroup(:B,2))
Dict{Symbol, Array} with 8 entries:
  :moduli                  => [3, 2]
  :minusculeWeights        => [[1, 3], [1], [2, 3], [2], [3]]
  :decompositions          => [[2, 1], [2, 0], [1, 1], [1, 0], [0, 1]]
  :highestroot             => [5, 7]
  :chosenAdaptedBasis      => [1 -1 0 0; 0 1 0 0; 0 0 1 0; 0 0 0 1]
  :minusculeCoweights      => [[1, 4], [1], [2, 4], [2], [4]]
  :CenterSimplyConnected   => Vector{Rational{Int64}}[[1//3, 2//3, 0, 0], [0, 0…
  :AdjointFundamentalGroup => [(1,12,2), (4,14)]

weights(W) simple weights in the basis of X(T)

centralizer(W,s::SemisimpleElement)

W should be a Weyl group or an extended reflection group and s a semisimple element of the algebraic group G corresponding to W. This function returns the Weyl group of $C_G(s)$, which describes it. The stabilizer is an extended reflection group, with the reflection group part equal to the Weyl group of $C_{G⁰}(s)$, and the diagram automorphism part being those induced by $C_G(s)$.

julia> G=coxgroup(:A,3)
A₃
julia> s=ss(G,[0,1//2,0])
SemisimpleElement{Root1}: <1,-1,1>
julia> centralizer(G,s)
A₃₍₁₃₎=(A₁A₁)Φ₂

Reflection is a struct representing a reflection in a reflection group.

julia> W=crg(8);

julia> r=reflections(W)[7] # shows (r.W,r.rootno,r.eigen)
Reflection(G₈,1,-1)

julia> r.rootno # r is a reflection for the first root
1

julia> r.eigen # the non-trival eigenvalue, as a Root1
Root1: -1

julia> r.W # the group of which r is a reflection
G₈

julia> r==Reflection(W,1,-1) # specify r with .rootno and .eigen
true

julia> Reflection(W,1) # specify with .rootno gets the distinguished reflection
Reflection(G₈,1,ζ₄)

julia> root(r)
2-element Vector{Cyc{Rational{Int64}}}:
  0
 ζ₄

julia> coroot(r)
2-element Vector{Cyc{Int64}}:
    0
 -2ζ₄

julia> Matrix(r)
2×2 Matrix{Cyc{Rational{Int64}}}:
 1   0
 0  -1

julia> hyperplane(r) # the fixed hyperplane, as a rowspace
1×2 Matrix{Cyc{Rational{Int64}}}:
 1  0

julia> hyperplane(r)*Matrix(r)==hyperplane(r)
true

julia> isdistinguished(r) # r is not distinguished
false

julia> exponent(r) # which power of a distinguished reflection it is
2

julia> Perm(r)
(1,8)(2,9)(3,16)(4,15)(5,17)(6,18)(7,19)(10,22)(11,21)(12,23)

julia> hyperplane_orbit(r) # r is in the first hyperplane orbit
1

julia> position_class(r) # the index of the conjugacy class of r in W 
15

julia> simple_rep(r) # smallest root index affording a conjugate reflection
1

julia> word(r) # a word in the generators of r.W for r
2-element Vector{Int64}:
 1
 1

codegrees(W::ComplexReflectionGroup)

returns the vector of codegrees of W as a reflection group on the space V of reflrep(W). These are one less than the degrees of the basic derivations of W on SV⊗ V^vee.

julia> W=complex_reflection_group(4)
G₄

julia> codegrees(W)
2-element Vector{Int64}:
 0
 2

complex_reflection_group(STnumber) or crg(STnumber)

complex_reflection_group(p,q,r) or crg(p,q,r)

The first form of complex_reflection_group returns the complex reflection group which has Shephard-Todd number STnumber, see Shephard-Todd1954. The second form returns the imprimitive complex reflection group G(p,q,r).

julia> G=complex_reflection_group(4)
G₄

julia> degrees(G)
2-element Vector{Int64}:
 4
 6

julia> length(G)
24

julia> W*coxgroup(:A,2) # how to make a non-irreducible group
G₄×A₂

julia> complex_reflection_group(1,1,3) # another way to enter A₂
gl₃

julia> crg(4) # there is also a short alias
G₄

degrees(WF::Spets)

Let W be the group of the reflection coset WF, and let V be the vector space of dimension rank(W) on which W acts as a reflection group. Let f₁,…,fₙ be the basic invariants of W on the symmetric algebra SV of V; they can be chosen so they are eigenvectors of the matrix WF.F. The corresponding eigenvalues are called the factors of F acting on V; they characterize the coset –- they are equal to 1 only for the trivial coset. The generalized degrees of WF are the pairs formed of the reflection degrees and the corresponding factor.

julia> W=coxgroup(:E,6)
E₆

julia> WF=spets(W)
E₆

julia> phi=W(6,5,4,2,3,1,4,3,5,4,2,6,5,4,3,1);

julia> HF=subspets(WF,2:5,phi)
E₆₍₂₃₄₅₎=³D₄Φ₃

julia> diagram(HF)
ϕ acts as (1,2,4) on the component below
  O 2
  ￨
O—O—O D₄
1 3 4

julia> degrees(HF)
6-element Vector{Tuple{Int64, Cyc{Int64}}}:
 (1, ζ₃)
 (1, ζ₃²)
 (2, 1)
 (4, ζ₃)
 (6, 1)
 (4, ζ₃²)

degrees(W::ComplexReflectionGroup)

returns a list holding the degrees of W as a reflection group on the vector space V on which it acts. These are the degrees d₁,…,dₙ where n is the dimension of V of the basic invariants of W in SV. They reflect various properties of W; in particular, their product is the cardinality of W.

julia> W=complex_reflection_group(30)
H₄

julia> degrees(W)
4-element Vector{Int64}:
  2
 12
 20
 30

julia> length(W)
14400

hyperplane_orbits(W::ComplexReflectionGroup)

returns a list of named tuples, one for each hyperplane orbit of the reflection group W. If o is the named tuple for such an orbit, and s is the first element of gens(W) whose hyperplane is in the orbit, it contains the following fields

.s: index of s in gens(W)

.order: order of s

.cl_s: for i in 1:order-1, position_class(W,W(s)^i)

.N_s: size of hyperplane orbit

.det_s: for i in 1:order-1, position in CharTable(W) of detₛⁱ, where detₛ is the linear character taking the value det(reflrep(W,s)) on s and 1 on non-conjugate reflections.

julia> W=coxgroup(:B,2)
B₂

julia> hyperplane_orbits(W)
2-element Vector{@NamedTuple{s::Int64, cl_s::Vector{Int64}, order::Int64, N_s::Int64, det_s::Vector{Int64}}}:
 (s = 1, cl_s = [2], order = 2, N_s = 2, det_s = [5])
 (s = 2, cl_s = [4], order = 2, N_s = 2, det_s = [1])

reflections(W) a Vector{Reflection} of all reflections of the reflection group W (including the non-distinguished ones; see Reflection). reflections(W)[1:nhyp(W)] are the distinguished reflections.

julia> W=crg(4)
G₄

julia> reflections(W)
8-element Vector{Reflection{PRG{Cyc{Rational{Int64}}, Int16}}}:
 Reflection(G₄,1,ζ₃)
 Reflection(G₄,2,ζ₃)
 Reflection(G₄,4,ζ₃)
 Reflection(G₄,5,ζ₃)
 Reflection(G₄,1,ζ₃²)
 Reflection(G₄,2,ζ₃²)
 Reflection(G₄,4,ζ₃²)
 Reflection(G₄,5,ζ₃²)

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;

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

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=φ₃₅‚₂>

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]

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

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 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

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′₁

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.

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₂]:<φ″₁‚₃>+<φ₂‚₁>+<φ₂‚₂>

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₂]:<φ′₁‚₃>+<φ₂‚₁>+<φ₂‚₂>

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.

Wgraph(c::LeftCell)

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

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

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

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=φ₂‚₁+φ″₁‚₃+φ₂‚₂>

minimal_word(cond::Function,gens::Vector,e;action::Function=^) returns minimal word w such that composition(gens[w]) applied to e satifies cond

μ(W, y, w) highest coefficient of KLPol(W,y,w)

Lμ returns the coefficient of highest possible degree (l(w)-l(y)-1)/2 of KLPol(W,y,w). It is 0 unless y≤w for the Bruhat order.

Number fields are the finite extensions of ℚ. The only ones that we can handle at the moment are subfields of cyclotomic fields, that is whose elements are Cycs; they are also characterized as the number fields K such that Gal(K/ℚ) is abelian. For example, ℚ (√5) is a number field that is not cyclotomic but contained in the cyclotomic field ℚ (ζ₅).

The default constructor for a number field takes some numbers as arguments and constructs the smallest number field containing its arguments.

julia> F=NF(E(5)) # the full cyclotomic field prints as CF
CF(5)

julia> K=NF(root(5)) # a subfield
NF(5,-1₅)

julia> conductor(K) # smallest n such that K is a subfield of CF(n)
5

julia> E(5)+E(5,-1) in NF(root(5)) # test if an element is in the subfield
true

A number field K is printed by given the conductor of the smallest cyclotomic field F containing it, and generators of the stabilizer of K in the galois group of F. Above NF(5,-1₅) represents the subfield of CF(5) stable by complex conjugacy.

julia> elements(galois(F))
4-element Vector{Chevie.Nf.NFAut}:
 Aut(CF(5),1₅)
 Aut(CF(5),2₅)
 Aut(CF(5),-1₅)
 Aut(CF(5),-2₅)

The element of the galois group of CF(5) printed -2₅ acts by raising the fifth roots of unity to the power -2. Thus -1₅ represents complex conjugacy.

julia> NF(root(3),root(5)) # here the stabilizer needs 2 generators
NF(60,-11₆₀,-1₆₀)

Aut(F::NumberField,k::Union{Integer,Mod})

The Galois automorphism σₖ of the cyclotomic field CF(n) raises n-th roots of unity to the power k; it exists for k prime to n. If F is a subfield of CF(n), the elements of the orbit of σₖ modulo the stabilizer of F in the Galois group galois(CF(n)) have same restriction to F. An automorphism of F is represented by a canonical representative σₗ of this orbit. This is the result of Aut(F,k). The number k can be given as an integer or as Mod(k,n).

julia> F=NF(root(5))
NF(5,-1₅)

julia> s=Aut(F,3)
Aut(NF(5,-1₅),2₅)

julia> root(5)^s # action of s on a Cyc
Cyc{Int64}: -√5

CF(N::Integer) the cyclotomic field generated by the N-th roots of unity.

LenstraBase(n,stab,supergroup)

returns a list [b₁,…,bₘ] of Mod(-,n) lists, each bᵢ describing the cyclotomic βᵢ=∑_{j∈ bᵢ} ζₙʲ such that the βᵢ form a base of the integer ring of the number field NF(n,stab).

supergroup is a group containing stab; the base is chosen such that the group of supergroup acts on it, as far as this is possible.

Note: the bᵢ are in general not sorted, since bᵢ[1] is often an element of zumbroich_basis(n).

stab must not contain the stabilizer of a proper cyclotomic subfield of CF(n).

julia> Nf.LenstraBase(24,Group([Mod(19,24)]),Group([Mod(19,24)]))
4-element Vector{Vector{Mod{UInt64}}}:
 [1₂₄, -5₂₄]
 [8₂₄]
 [11₂₄, -7₂₄]
 [-8₂₄]

julia> Nf.LenstraBase(24,Group([Mod(19,24)]),Group([Mod(19,24),Mod(5,24)]))
4-element Vector{Vector{Mod{UInt64}}}:
 [1₂₄, -5₂₄]
 [5₂₄, -1₂₄]
 [8₂₄]
 [-8₂₄]

julia> Nf.LenstraBase(15,Group([Mod(4,15)]),Group(Mod.(prime_residues(15),15)))
4-element Vector{Vector{Mod{UInt64}}}:
 [1₁₅, 4₁₅]
 [2₁₅, -7₁₅]
 [7₁₅, -2₁₅]
 [-4₁₅, -1₁₅]

NF(gens...) or NF(gens::AbstractVector)

returns the smallest number field containing the elements gens, which may be Cyc, Root1, Integer or Rational{<:Integer}.

julia> NF(E(3),root(5))
NF(15,4₁₅)

julia> NF([E(3),root(5)])
NF(15,4₁₅)

NF(N::Integer, stab::Group{<:Mod}) fixed field of the subgroup stab of galois(CF(N)) in CF(N). stab should not inject in the multiplicative group of a proper divisor of N.

gens_prime_residues(n::Integer) generators of multiplicative group (ℤ /n)ˣ

For each odd prime p there is one generator, corresponding to a primitive root of the subgroup (ℤ /nₚ)ˣ of the multiplicative group (ℤ /n)ˣ, where nₚ is the highest power of p dividing n. For p=2, we have one generator unless n₂ is a multiple of 8, in which case there are two generators 5 and n₂-1. The function returns a Dict recording for each p, the list of generators of (ℤ/nₚ)ˣ.

julia> Nf.gens_prime_residues( 24 )
Dict{Int64, Vector{Int64}} with 2 entries:
  2 => [7, 13]
  3 => [17]

galois(F::NumberField) Galois group of F over ℚ

the Galois group of F, a number field of conductor n, is the quotient of the Galois group of CF(n), isomorphic to the multiplicative group (ℤ/n)ˣ, by the stabilizer of F. It is given as a group of Galois automorphisms (see Aut).

julia> K=CF(5)
CF(5)

julia> F=NF(root(5))
NF(5,-1₅)

julia> galois(K)
Group(Chevie.Nf.NFAut[Aut(CF(5),2₅)])

julia> elements(galois(K))
4-element Vector{Chevie.Nf.NFAut}:
 Aut(CF(5),1₅)
 Aut(CF(5),2₅)
 Aut(CF(5),-1₅)
 Aut(CF(5),-2₅)

julia> elements(galois(F))
2-element Vector{Chevie.Nf.NFAut}:
 Aut(NF(5,-1₅),1₅)
 Aut(NF(5,-1₅),2₅)

Let R be a root system in the real vector space V. We say that F₀∈ GL(V) is an automorphism of R if it permutes R and is of finite order (finite order is automatic if R generates V). It follows by chap. VI, §1.1, lemme 1 Bourbaki1968 that the dual F₀*∈ GL(V*) permutes the coroots R*⊂ V*; thus F₀ normalizes the reflection group W associated to R, that is w↦ F₀wF₀⁻¹ is an automorphism of W. Thus we get a reflection coset WF₀, which we call a Coxeter coset.

The motivation for introducing Coxeter cosets comes from automorphisms of algebraic reductive groups, giving rise to non-split reductive groups over finite fields. Let 𝐆 be a connected reductive algebraic group 𝐆 over an algebraic closure 𝔽̄_q of a finite field 𝔽_q, defined over 𝔽_q; this corresponds to a Frobenius endomorphism F so that the finite group of rational points 𝐆(𝔽_q) identifies to the subgroup 𝐆^F of fixed points under F.

Let 𝐓 be a maximal torus of 𝐆, and Φ (resp. Φ*) be the roots (resp. coroots) of 𝐆 with respect to 𝐓 in the character group X(𝐓) (resp. the group of one-parameter subgroups Y(𝐓)). Then 𝐆 is determined up to isomorphism by (X(𝐓),Φ,Y(𝐓),Φ*); this corresponds to give a root system in the vector space V=ℚ ⊗ X(𝐓) and a rational reflection group W=N_𝐆(𝐓)/𝐓 acting on it.

If 𝐓 is F-stable the Frobenius endomorphism F acts also naturally on X(T) and defines thus an endomorphism of V, which is of the form q F₀, where F₀∈ GL(V) is of finite order and normalizes W. We get thus a Coxeter coset WF₀⊂GL(V). The data (X(𝐓), Φ, Y(𝐓), Φ*, F₀), and the integer q completely determine up to isomorphism the associated reductive finite group 𝐆^F. Thus these data is a way of representing in the essential information which determines a finite reductive group. Indeed, all properties of Chevalley groups can be computed from that datum: symbols representing characters, conjugacy classes, and finally the whole character table of 𝐆^F.

It turns out that many interesting objects attached to this datum depend only on (V,W, F₀): the order of the maximal tori, the fake degrees, the order of 𝐆^F, symbols representing unipotent characters, Deligne-Lusztig induction in terms of almost characters, the Fourier matrix relating characters and almost characters, etc… (see, e.g., Broue-Malle-Michel1993). It is thus possible to extend their construction to non-crystallographic groups (or even to more general complex reflection groups, see spets); this is why we did not include a root system in the definition of a reflection coset. However, unipotent conjugacy classes for instance depend on the root system.

We assume now that 𝐓 is contained in an F-stable Borel subgroup of 𝐆. This defines an order on the roots, and there is a unique element ϕ∈ W F₀, the reduced element of the coset, which preserves the set of positive roots. It thus defines a diagram automorphism, that is an automorphism of the Coxeter system (W,S). This element is stored in the component .phi of the coset record. It may be defined without mentioning the roots, as follows: (W,F₀(S)) is another Coxeter system, thus conjugate to S by a unique element of W, thus there is a unique element ϕ∈ WF₀ which stabilizes S (a proof follows from Theoreme 1, chap. V, §3 Bourbaki1968). We consider thus cosets of the form Wϕ where ϕ stabilizes S. The coset W ϕ is completely defined by the permutation .phi when 𝐆 is semi-simple –- equivalently when Φ generates V; in this case we just need to specify phi to define the coset.

There is a slight generalisation of the above setup, covering in particular the case of the Ree and Suzuki groups. We consider 𝐆^F where F not a Frobenius endomorphism, but an isogeny such that some power F^n is a Frobenius endomorphism. Then F still defines an endomorphism of V which normalizes W; we define a real number q such that F^n is attached to an 𝔽_{qⁿ}-structure. Then we still have F=q F₀ where F₀ is of finite order but q is no more an integer. Thus F₀∈ GL(V⊗ ℝ) but F₀∉ GL(V). For instance, for the Ree and Suzuki groups, F₀ is an automorphism of order 2 of W, which is of type G₂, B₂ or F₄, and q=√2 for B₂ and F₄ and q=√3 for G₂ This can be constructed starting from root systems for G₂, B₂ or F₄ where all the roots have the same length. This kind of root system is not crystallographic. Such non-crystallographic root systems exist for all finite Coxeter groups such as the dihedral groups, H₃ and H₄. We will call here Weyl cosets the cosets corresponding to rational forms of algebraic groups, which include thus some non-rational roots systems for B₂, G₂ and F₄.

Spets

We now extend the above notions to general complex reflection groups. Let W⊂ GL(V) be a complex reflection group on the vector space V. Let ϕ be an element of GL(V) which normalizes W. Then the coset Wϕ is called a reflection coset.

A reference for these cosets is Broue-Malle-Michel 1999. When W is a so-called Spetsial group, they are the basic object for the construction of a Spetses, which is an object attached to a complex reflection group from which one can derive combinatorially some attributes shared with finite reductive groups, like unipotent degrees, etc….

We say that a reflection coset is irreducible if W is irreducible. A general coset is a direct product of descents of scalars, which is the case where ϕ is transitive on the irreducible components of W. The irreducible cosets have been classified in Broue-Malle-Michel 1999: up to multiplication of ϕ by a scalar, there is usually only one or two possible cosets for a given irreducible group.

We deal only with finite order cosets, that is, we assume there is a (minimal) integer δ such that (Wϕ)^δ=W. Then the group generated by W and ϕ is finite, of order δ|W|.

A subset C of a Wϕ is called a conjugacy class if one of the following equivalent conditions is fulfilled:

• C is the orbit of an element in Wϕ under the conjugation action of W.

• C is a conjugacy class of ⟨W,ϕ⟩ contained in Wϕ.

• The set {w∈ W|wϕ∈ C} is a ϕ-conjugacy class of W (two elements

v,w∈ W are called ϕ-conjugate, if and only if there exists x∈ W with v=xwϕ(x⁻¹)).

An irreducible character of ⟨W,ϕ⟩ has some non-zero values on Wϕ if and only if its restriction to W is irreducible. Further, two characters χ₁ and χ₂ which have same irreducible restriction to W differ by a character of the cyclic group ⟨ϕ⟩ (which identifies to the quotient ⟨W,ϕ⟩/W). A set containing one extension to ⟨W,ϕ⟩ of each ϕ-invariant character of W is called a set of irreducible characters of Wϕ. Two such characters are orthogonal for the scalar product on the class functions on Wϕ given by $⟨χ,ψ⟩:=|W|¹∑_{w∈ W}χ(wϕ)\overline{ψ(wϕ)}.$ For rational groups (Weyl groups), Lusztig has defined a choice of a set of irreducible characters for Wϕ (called the preferred extensions), but for more general reflection cosets we have made some rather arbitrary choices, which however have the property that their values lie in the smallest possible field.

The character table of Wϕ is the table of values of a set of irreducible characters on the conjugacy classes.

A subcoset Lwϕ of Wϕ is given by a reflection subgroup L of W and an element w of W such that wϕ normalizes L.

We then have a natural notion of restriction of class functions on Wϕ to class functions on Lwϕ as well as of induction in the other direction. These maps are adjoint with respect to the scalar product defined above (see Broue-Malle-Michel 1999).

In this package the most general construction of a reflection coset is by starting from a reflection datum, and giving in addition the matrix F of the map ϕ:V→ V (see the command spets). However, at present, general cosets are only implemented for groups represented as permutation groups on a set of roots, and it is required that the automorphism given preserves this set up to a scalar (it is allowed that these scalars depend on the pair of an irreducible component and its image). It is also allowed to specify ϕ by the permutation it induces on the roots; in this case it is assumed that ϕ acts trivially on the orthogonal of the roots, but the roots could be those of a parent group, generating a larger space. Thus in any case we have a permutation representation of ⟨W,ϕ⟩ and we consider the coset to be a set of permutations.

Reflection cosets are implemented in by a struct which points to a reflection group record and has additional fields holding F and the corresponding permutation phi. In the general case, on each component of W which is a descent of scalars, F will permute the components and differ by a scalar on each component from an automorphism which preserves the roots. In this case, we have a permutation phi and a scalar which is stored for that component.

The most common situation where cosets with non-trivial phi arise is as sub-cosets of reflection groups. Here is an "exotic" example, see the next chapter for more classical examples involving Coxeter groups.

julia> W=complex_reflection_group(14)
G₁₄

julia> R=reflection_subgroup(W,[2,4])
G₁₄₍₂₄₎=G₅

julia> RF=spets(R,W(1)) # should be ²G₅(√6)
G₁₄₍₂₄₎=²G₅

julia> diagram(RF)
ϕ acts as (1,2) on the component below
③ ══③ G₅
1   2

julia> degrees(RF)
2-element Vector{Tuple{Int64, Cyc{Int64}}}:
 (6, 1)
 (12, -1)

The last line shows for each reflection degree the corresponding factor of the coset, which is the scalar by which ϕ acts on the corresponding fundamental reflection invariant. The factors characterize the coset.

A spets by default is printed in an abbreviated form which describes its type, as above (G₅ twisted by 2, with a Cartan matrix which differs from the standard one by a factor of √6). The function repr gives a form which could be input back in Julia. With the same data as above we have:

julia> print(RF)
spets(reflection_subgroup(complex_reflection_group(14),[2, 4]),perm"(1,3)(2,4)(5,9)(6,10)(7,11)(8,12)(13,21)(14,22)(15,23)(16,24)(17,25)(18,26)(19,27)(20,28)(29,41)(30,42)(31,43)(32,44)(33,45)(34,46)(35,47)(36,48)(37,49)(38,50)(39,51)(40,52)(53,71)(54,72)(55,73)(56,74)(57,75)(58,76)(59,77)(60,78)(62,79)(64,80)(65,81)(66,82)(67,69)(68,70)(83,100)(84,101)(85,102)(87,103)(89,99)(90,97)(91,98)(92,96)(93,104)(94,95)(105,113)(106,114)(109,111)(110,112)(115,118)(116,117)(119,120)")

Conjugacy classes and irreducible characters of Coxeter cosets are defined as for general reflection cosets. For irreducible characters of Weyl cosets, we choose (following Lusztig) for each ϕ-stable character of W a particular extension to a character of W⋊ ⟨ϕ⟩, which we will call the preferred extension. The character table of the coset Wϕ is the table of the restrictions to Wϕ of the preferred extensions. The question of finding the conjugacy classes and character table of a Coxeter coset can be reduced to the case of irreducible root systems R.

• The automorphism ϕ permutes the irreducible components of W, and Wϕ is a direct product of cosets where ϕ permutes cyclically the irreducible components of W. The preferred extension is defined to be the direct product of the preferred extension in each of these situations.

• Assume now that Wϕ is a descent of scalars, that is the decomposition in irreducible components W=W₁× ⋯ × Wₖ is cyclically permuted by ϕ. Then there are natural bijections from the ϕ-conjugacy classes of W to the ϕᵏ-conjugacy classes of W₁ as well as from the ϕ-stable characters of W to the ϕᵏ-stable characters of W₁, which reduce the definition of preferred extensions on Wϕ to the definition for W₁ϕᵏ.

• Assume now that W is the Coxeter group of an irreducible root system. ϕ permutes the simple roots, hence induces a graph automorphism on the corresponding Dynkin diagram. If ϕ=1 then conjugacy classes and characters coincide with those of the Coxeter group W.

The nontrivial cases for crystallographic roots systems are (the order of ϕ is written as left exponent to the type): ²Aₙ, ²Dₙ, ³D₄, ²E₆. For non-crystallographic root systems where all the roots have the same length the additional cases ²B₂, ²G₂, ²F₄ and ²I₂(k) arise.

• In case ³D₄ the group W⋊ ⟨ϕ⟩ can be embedded into the Coxeter group of type F₄, which induces a labeling for the conjugacy classes of the coset. The preferred extension is chosen as the (single) extension with rational values.

• In case ²Dₙ the group W⋊ ⟨ϕ⟩ is isomorphic to a Coxeter group of type Bₙ. This induces a canonical labeling for the conjugacy classes of the coset and allows to define the preferred extension in a combinatorial way using the labels (pairs of partitions) for the characters of the Coxeter group of type Bₙ.

• In the remaining crystallographic cases ϕ identifies to -w₀ where w₀ is the longest element of W. So, there is a canonical labeling of the conjugacy classes and characters of the coset by those of W. The preferred extensions are defined by describing the signs of the character values on -w₀.

The most general construction of a Coxeter coset is by starting from a Coxeter datum specified by the matrices of simpleRoots and simplecoroots, and giving in addition the matrix F0Mat of the map F₀:V→ V (see the commands CoxeterCoset and CoxeterSubCoset). As for Coxeter groups, the elements of Wϕ are uniquely determined by the permutation they induce on the set of roots R. We consider these permutations as elements of the Coxeter coset.

Coxeter cosets are implemented by a struct which points to a Coxeter datum record and has additional fields holding F0Mat and the corresponding element phi. Functions on the coset (for example, classinfo) are about properties of the group coset W ϕ ; however, most definitions for elements of untwisted Coxeter groups apply without change to elements in W ϕ: e.g., if we define the length of an element wϕ∈ Wϕ as the number of positive roots it sends to negative ones, it is the same as the length of w, i.e., ϕ is of length 0, since ϕ has been chosen to preserve the set of positive roots. Similarly, the Coxeter word describing wϕ is the same as the one for w, etc…

We associate to a Coxeter coset Wϕ a twisted Dynkin diagram, consisting of the Dynkin diagram of W and the graph automorphism induced by ϕ on this diagram (this specifies the group W⋊ ⟨F⟩, mentioned above, up to isomorphism). See the functions ReflectionType, ReflectionName and diagram for Coxeter cosets.

Below is an example showing first how to not define, then how to define, the Weyl coset for a Suzuki group:

julia> W=coxgroup(:B,2)
B₂

julia> spets(W,Perm(1,2))
ERROR: matrix F must preserve the roots
Stacktrace:
 [1] error(::String) at ./error.jl:33
 [2] spets(::Chevie.Weyl.FCG{Int16,Int64,PRG{Int64,Int16}}, ::Matrix{Int64}) at /home/jmichel/julia/Chevie/src/Cosets.jl:241 (repeats 2 times)
 [3] top-level scope at REPL[19]:1

julia> W=coxgroup(:Bsym,2)
Bsym₂

julia> WF=spets(W,Perm(1,2))
²Bsym₂

julia> CharTable(WF)
CharTable(²Bsym₂)
┌───┬─────────┐
│   │    1 121│
├───┼─────────┤
│2. │1   1   1│
│.11│1  -1  -1│
│1.1│. -√2  √2│
└───┴─────────┘

A subcoset Hwϕ of Wϕ is given by a reflection subgroup H of W and an element w of W such that wϕ induces an automorphism of the root system of H. For algebraic groups, this corresponds to a rational form of a reductive subgroup of maximal rank. For example, if Wϕ corresponds to the algebraic group 𝐆 and H is the trivial subgroup, the coset Hwϕ corresponds to a maximal torus 𝐓_w of type w.

julia> W=coxgroup(:Bsym,2)
Bsym₂

julia> WF=spets(W,Perm(1,2))
²Bsym₂

julia> subspets(WF,Int[],W(1))
²Bsym₂₍₎=Φ‴₈

A subgroup H which is a parabolic subgroup corresponds to a rational form of a Levi subgroup of 𝐆. The command twistings gives all rational forms of such a Levi.

julia> W=coxgroup(:B,2)
B₂

julia> twistings(W,[1])
2-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 B₂₍₁₎=Ã₁Φ₁
 B₂₍₁₎=Ã₁Φ₂

julia> twistings(W,[2])
2-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 B₂₍₂₎=A₁Φ₁
 B₂₍₂₎=A₁Φ₂

Notice how we distinguish between subgroups generated by short roots and by long roots. A general H corresponds to a reductive subgroup of maximal rank. Here we consider the subgroup generated by the long roots in B₂, which corresponds to a subgroup of type SL₂× SL₂ in SP₄, and show its possible rational forms.

julia> W=coxgroup(:B,2)
B₂

julia> twistings(W,[2,4])
2-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 B₂₍₂₄₎=A₁×A₁
 B₂₍₂₄₎=(A₁A₁)

Frobenius(WF)(x,i=1)

If WF is a Coxeter coset associated to the Coxeter group W, Frobenius(WF) returns a function F such that x↦ F(x,i=1) does the automorphism induced by WF.phi^i on the object x.

julia> W=coxgroup(:D,4)
D₄

julia> WF=spets(W,Perm(1,2,4))
³D₄

julia> u=unichar(W,2)
[D₄]:<11->

julia> F=Frobenius(WF);F(u)
[D₄]:<.211>

julia> F(u,-1)
[D₄]:<11+>

julia> F(1)
4

graph_automorphisms(t::Vector{TypeIrred})

Given the refltype of a finite Coxeter group, returns the group of all Graph automorphisms of t as a group of permutations of indices(t).

julia> W=coxgroup(:D,4)
D₄

julia> graph_automorphisms(refltype(W*W))
Group((1,5)(2,6)(3,7)(4,8),(1,2),(1,4))

spets(s::String) builds a few of the exceptional spets

julia> spets("3G422")
³G₄‚₂‚₂

julia> spets("2G5")
²G₅

julia> spets("3G333")
G₃‚₃‚₃₍₁‚₂‚₃‚₄₄₎=³G₃‚₃‚₃₍₁‚₂‚₃‚₄₄₎

julia> spets("3pG333")
G₃‚₃‚₃₍₁‚₂‚₃‚₄₄₎=³G₃‚₃‚₃₍₁‚₂‚₃‚₄₄₎

julia> spets("4G333")
G₃‚₃‚₃₍₂‚₁₂‚₁₁‚₁₆‚₅₃‚₁₀‚₄₃‚₃₆₎=⁴G₃‚₃‚₃₍₁‚₂‚₃‚₃₂‚₁₆‚₃₆‚₃₀‚₁₀₎

spets(W::ComplexReflectionGroup, F::Matrix=I(rank(W)))

This function returns a or a CoxeterCoset or a Spets. F must be an invertible matrix, representing an automorphism of the vector space V of dimension of dimension rank(W) which for a finite Coxeter group induces an automorphism of the root system of parent(W), or for a more general complex reflection group just stabilizes W.

The returned struct has in particular the following fields:

.W: the group W

.F: the matrix acting on V which represents the unique element phi in WF which preserves the positive roots (for finite Coxeter groups) or some "canonical" representative of the coset for more general complex reflection groups.

.phi: a Perm, the permutation of the roots of W induced by .F (for general complex reflection groups this may be a permutation up to scalars) (also for Coxeter groups the element of smallest length in the NormalCoset W .phi).

In the first example we create a Coxeter coset corresponding to the general unitary group GU_3(q) over the finite field FF(q).

julia> W=rootdatum(:gl,3)
gl₃

julia> gu3=spets(W,-reflrep(W,W()))
²A₂Φ₂

julia> F4=coxgroup(:F,4);D4=reflection_subgroup(F4,[1,2,16,48])
F₄₍₉‚₂‚₁‚₁₆₎=D₄₍₃₂₁₄₎

julia> spets(D4,[1 0 0 0;0 1 2 0;0 0 0 1;0 0 -1 -1])
F₄₍₉‚₁₆‚₁‚₂₎=³D₄₍₃₄₁₂₎

spets(W::ComplexReflectionGroup,p::Perm)

In this version F is defined by the permutation of the simple roots it does.

julia> W=coxgroup(:A,3)
A₃

julia> spets(W,Perm(1,3))
²A₃

subspets(WF,I,w=one(Group(WF)))

Returns the reflection subcoset of the coset WF with group reflection_subgroup(Group(WF),I) and torsion w*WF.phi. w must be an element of Group(WF) such that w*WF.phi normalizes the subroot system generated by I.

julia> WF=spets(coxgroup(:F,4))
F₄

julia> w=transporting_elt(Group(WF),[1,2,9,16],[1,9,16,2],ontuples);

julia> LF=subspets(WF,[1,2,9,16],w)
F₄₍₉‚₁₆‚₁‚₂₎=³D₄₍₃₄₁₂₎

julia> diagram(LF)
ϕ acts as (2,3,4) on the component below
  O 4
  ￨
O—O—O D₄
3 1 2

twistings(W,I)

W should be a complex reflection group.

The function returns the list, up to W-conjugacy, of subspets of W whose group is reflection_subgroup(W,I) –- In the case of Weyl groups, it corresponds to representatives of the possible twisted forms of the reductive subgroup of maximal rank L defined by reflection_subgroup(W,I).

W could also be a coset Wϕ; then the subgroup L must be conjugate to ϕ(L) for a rational form to exist. If ϕ normalizes L, then the rational forms are classified by the the ϕ-classes of N_W(L)/L.

julia> W=coxgroup(:E,6)
E₆

julia> WF=spets(W,Perm(1,6)*Perm(3,5))
²E₆

julia> twistings(W,2:5)
3-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 E₆₍₂₃₄₅₎=D₄Φ₁²
 E₆₍₂₃₄₅₎=³D₄Φ₃
 E₆₍₂₃₄₅₎=²D₄Φ₁Φ₂


julia> twistings(WF,2:5)
3-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 ²E₆₍₂₅₄₃₎=²D₄₍₁₄₃₂₎Φ₁Φ₂
 ²E₆₍₂₅₄₃₎=³D₄₍₁₄₃₂₎Φ₆
 ²E₆₍₂₃₄₅₎=D₄Φ₂²

twistings(W)

W should be a Coxeter group which is not a proper reflection subgroup of another reflection group (so that inclusion(W)==eachindex(roots(W))). The function returns all spets representing twisted forms of algebraic groups of type W.

julia> twistings(coxgroup(:A,3)*coxgroup(:A,3))
8-element Vector{Spets{FiniteCoxeterGroup{Perm{Int16},Int64}}}:
 A₃×A₃
 A₃ײA₃
 ²A₃×A₃
 ²A₃ײA₃
 (A₃A₃)
 ²(A₃A₃)
 ²(A₃A₃)₍₁₂₃₆₅₄₎
 (A₃A₃)₍₁₂₃₆₅₄₎

julia> twistings(coxgroup(:D,4))
6-element Vector{Spets{FiniteCoxeterGroup{Perm{Int16},Int64}}}:
 D₄
 ²D₄₍₂₄₃₁₎
 ²D₄
 ³D₄
 ²D₄₍₁₄₃₂₎
 ³D₄₍₁₄₃₂₎

julia> W=rootdatum(:so,8)
so₈

julia> twistings(W)
2-element Vector{Spets{FiniteCoxeterGroup{Perm{Int16},Int64}}}:
 D₄
 ²D₄

rootdatum(type::String or Symbol[,dimension or bond::Integer]) root datum from type. The known types are

2B2, 2E6, 2E6sc, 2F4, 2G2, 2I2, 3D4, 3D4sc, 3gpin8, CE6, CE7, E6, E6sc, E7, E7sc, E8, F4, G2, cso, csp, gl, gpin, gpin-, halfspin, pgl, pso, pso-, psp, psu, ree, sl, slmod, so, so-, sp, spin, spin-, su, suzuki, tgl, triality, u

torus(m::AbstractMatrix)

m should be a matrix of finite order. The function returns the coset T of the trivial group such that T.F==m. When m is integral his corresponds to an algebraic torus 𝐓 of rank size(m,1), with an isogeny which acts by m on X(𝐓).

julia> torus([0 -1;1 -1])
Φ₃

torus(W,i)

where W is a Spets or a ComplexReflectionGroup. This returns the torus twisted by a representative of the i-th conjugacy class of W. This is the same as twistings(W,Int[])[i].

julia> W=coxgroup(:A,3)
A₃

julia> twistings(W,Int[])
5-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 A₃₍₎=Φ₁³
 A₃₍₎=Φ₁²Φ₂
 A₃₍₎=Φ₁Φ₂²
 A₃₍₎=Φ₁Φ₃
 A₃₍₎=Φ₂Φ₄

julia> torus(W,2)
A₃₍₎=Φ₁²Φ₂

julia> WF=spets(W,Perm(1,3))
²A₃

julia> twistings(WF,Int[])
5-element Vector{Spets{FiniteCoxeterSubGroup{Perm{Int16},Int64}}}:
 ²A₃₍₎=Φ₂³
 ²A₃₍₎=Φ₁Φ₂²
 ²A₃₍₎=Φ₁²Φ₂
 ²A₃₍₎=Φ₂Φ₆
 ²A₃₍₎=Φ₁Φ₄

julia> torus(WF,2)
²A₃₍₎=Φ₁Φ₂²

A suitable reference for the general theory of Coxeter groups is, for example, Bourbaki "Lie Groups and Lie Algebras" chapter 4.

A Coxeter group is a group which has the presentation $W=⟨S|(st)^{m(s,t)}=1\text{ for }s,t∈ S⟩$ for some symmetric integer matrix m(s,t) called the Coxeter matrix, where m(s,t)>1 for s≠t and m(s,s)=1; m(s,t)=∞ is allowed meaning there is no relation between s and t. It is true (but a non-trivial theorem) that in a Coxeter group the order of st is exactly m(s,t), thus a Coxeter group is the same as a Coxeter system, that is a pair (W,S) of a group W and a set S⊂W of involutions, such that the group is presented by generators S and relations describing the order of the product of two elements of S.

A Coxeter group has a natural representation, its reflection representation, on a real vector space V of dimension length(S) (which is the Coxeter rank of W), where each element of S acts as a reflection; the faithfulness of this representation (a theorem of Tits) is the main argument to prove that the order of st is exactly m(s,t). This representation is defined as follows on a space V with basis {eₛ} for s∈ S. The cartan matrix associated to the Coxeter matrix m(s,t) is the matrix C with entries C(s,t)=-2cos(π/m(s,t)); we set C(s,t)=-2 if m(s,t)=∞. Then the action of s∈ S on V is given by s(eₜ)=eₜ-C(s,t)eₛ.

Thus, Coxeter groups are real reflection groups. The converse need not be true if the set of reflecting hyperplanes has bad topological properties, but it turns out that finite Coxeter groups are the same as finite real reflection groups. The possible Coxeter matrices for finite Coxeter groups have been completely classified, see Weyl; the corresponding finite groups play a deep role in several areas of mathematics.

Coxeter groups have a nice solution to the word problem. The length l(w) of an element w∈ W is the minimum number of elements of S of which it is a product (since the elements of S are involutions, we do not need inverses). An expression of w of minimum length is called a reduced word for w. The main property of reduced words is the exchange lemma which states that if s₁…sₖ is a reduced word for w (thus k=l(w)) and s∈ S is such that l(sw)≤l(w) then one of the sᵢ in the word for w can be deleted to obtain a reduced word for sw. Thus given s∈ S and w∈ W, either l(sw)=l(w)+1 or l(sw)=l(w)-1 and in the latter case we say that s belongs to the left descent set of w. Computing a reduced word for an element, and other word problems, are easy if we know how to multiply elements and know left descent sets. In each of the Coxeter groups that we implement, the left descent set is easy to compute (see for example coxeter_symmetric_group below), so this suggests how to deal with Coxeter groups generically:

The type CoxeterGroup is an abstract type; an actual struct which implements it must define a function

isleftdescent(W,w,i) which tells whether the i-th element of S is in the left descent set of w.

the other functions needed in an instance of a Coxeter group are

• gens(W) which returns the set S (the list of Coxeter generators)
• nref(W) which returns the number of reflections of W, if W is finite or nothing if W is infinite.

It should be noted that a Coxeter group can be any kind of group implementing the above functions.

Because of the easy solution of the word problem in Coxeter groups, a convenient way to represent their elements is as words in the Coxeter generators, that is lists of integers in 1:length(S). The functions 'word' and 'W(...)' do the conversion between Coxeter words and elements of the group.

Examples

julia> W=coxsym(4)
𝔖 ₄

julia> p=W(1,3,2,1,3)
(1,4)

julia> word(W,p)
5-element Vector{Int64}:
 1
 2
 3
 2
 1

We notice that the word we started with and the one that we ended up with, are not the same, even though they represent the same element of W. The reason is that there are several reduced words for an element of W. The function 'word' calculates a lexicographically smallest word for w. Below are some other possible computations using the same Coxeter group:

julia> word(W,longest(W))  # the (unique) longest element in W
6-element Vector{Int64}:
 1
 2
 1
 3
 2
 1

julia> w0=longest(W)
(1,4)(2,3)

julia> length(W,w0)
6
julia> map(w->word(W,w),refls(W,1:nref(W)))
6-element Vector{Vector{Int64}}:
 [1]
 [2]
 [3]
 [1, 2, 1]
 [2, 3, 2]
 [1, 2, 3, 2, 1]
julia> [length(elements(W,i)) for i in 0:nref(W)]
7-element Vector{Int64}:
 1
 3
 5
 6
 5
 3
 1

The last list tells us that there is 1 element of length 0, there are 6 of length 3, …

For most basic functions the convention is that the input is an element of the group, rather than a Coxeter word. The reason for this is that for a Coxeter group which is a permutation group, using the low level functions for permutations is usually much faster than manipulating lists representing reduced expressions.

The only Coxeter group constructors implemented in this module are coxsym and coxgroup; the last constructor takes a Cartan matrix and builds the corresponding Coxeter group as a matrix group. The module Weyl defines other methods for coxgroup building a finite Coxeter group as a permutation group, given its type.

Poset(W::CoxeterGroup,w=longest(W))

returns as a poset the Bruhat interval [1,w]of W. If w is not given, the whole Bruhat Poset of W is returned (W must then be finite).

julia> W=coxsym(3)
𝔖 ₃

julia> Poset(W)
.<1,2<21,12<121

The above poset is constructed efficiently by constructing the Hasse diagram, but it could be constructed naively as follows:

julia> p=Poset((x,y)->bruhatless(W,x,y),elements(W))
()<(1,2),(2,3)<(1,3,2),(1,2,3)<(1,3)

The output is not so nice, showing permutations instead of words. This can be fixed by defining:

julia> p.show_element=(io,x,n)->join(io,word(W,x.elements[n]));

julia> p
<1,2<12,21<121

julia> W=coxsym(4)
𝔖 ₄

julia> Poset(W,W(1,3))
.<3,1<13

length(W::CoxeterGroup ,w)

returns the length of a reduced expression in the Coxeter generators of the element w of W.

julia> W=coxsym(4)
𝔖 ₄

julia> p=W(1,2,3,1,2,3)
(1,3)(2,4)

julia> length(W,p)
4

julia> word(W,p)
4-element Vector{Int64}:
 2
 1
 3
 2

braid_relations(W)

this function returns the relations which present the braid group of the reflection group W. These are homogeneous (both sides of the same length) relations between generators in bijection with the generating reflections of W. A presentation of W is obtained by adding relations specifying the order of the generators.

julia> W=complex_reflection_group(29)
G₂₉

julia> braid_relations(W)
7-element Vector{Tuple{Vector{Int64}, Vector{Int64}}}:
 ([1, 2, 1], [2, 1, 2])
 ([2, 4, 2], [4, 2, 4])
 ([3, 4, 3], [4, 3, 4])
 ([2, 3, 2, 3], [3, 2, 3, 2])
 ([1, 3], [3, 1])
 ([1, 4], [4, 1])
 ([4, 3, 2, 4, 3, 2], [3, 2, 4, 3, 2, 4])

each relation is represented as a pair of lists, specifying that the product of the generators according to the indices on the left side is equal to the product according to the indices on the right side. See also diagram.

bruhatless(W, x, y)

whether x≤y in the Bruhat order, for x,y∈ W. We have x≤y if a reduced expression for x can be extracted from one for w. See (5.9) and (5.10) Humphreys1990 for properties of the Bruhat order.

julia> W=coxgroup(:H,3)
H₃

julia> w=W(1,2,1,3);

julia> b=filter(x->bruhatless(W,x,w),elements(W));

julia> word.(Ref(W),b)
12-element Vector{Vector{Int64}}:
 []
 [1]
 [2]
 [3]
 [1, 2]
 [2, 1]
 [1, 3]
 [2, 3]
 [1, 2, 1]
 [1, 2, 3]
 [2, 1, 3]
 [1, 2, 1, 3]

bruhatless(W, y)

returns a vector whose i-th element is the vector of elements of W smaller for the Bruhat order than w and of Coxeter length i-1. Thus the first element of the returned list contains only one(W) and the length(W,w)-th element contains only w.

julia> W=coxsym(3)
𝔖 ₃

julia> bruhatless(W,Perm(1,3))
4-element Vector{Vector{Perm{Int16}}}:
 [()]
 [(1,2), (2,3)]
 [(1,2,3), (1,3,2)]
 [(1,3)]

see also Poset for Coxeter groups.

coxeter_group(m) or coxgroup(m)

m should be a square matrix of real cyclotomic numbers. It returns the Coxeter group whose Cartan matrix is m. This is a matrix group W constructed as follows. Let V be a real vector space of dimension size(m,1), let eᵢ be the canonical basis of V. Then W is the matrix group generated by the reflections sᵢ(eⱼ)=eⱼ-mᵢⱼ eᵢ.

julia> W=coxgroup([2 -2;-2 2])
coxeter_group([2 -2; -2 2])

Above is a way to construct the affine Weyl group Ã₁.

coxeter_hyperoctaedral_group(n) or coxhyp(n)

The Hyperoctaedral group (the group of all signed permutations of ±1,…,±n) as a Coxeter group of type Bₙ, with generators (1,-1) and (i,i+1)(-i,-i-1).

julia> elements(coxhyp(2))
8-element Vector{SPerm{Int8}}:
 ()
 (1,2)
 (1,-1)
 (1,2,-1,-2)
 (1,-2,-1,2)
 (2,-2)
 (1,-2)
 (1,-1)(2,-2)

coxeter_matrix(m::AbstractMatrix) or coxmat

returns the Coxeter matrix of the Coxeter group defined by the cartan matrix m

julia> C=cartan(:H,3)
3×3 Matrix{Cyc{Int64}}:
       2  ζ₅²+ζ₅³   0
 ζ₅²+ζ₅³        2  -1
       0       -1   2

julia> coxmat(C)
3×3 Matrix{Int64}:
 1  5  2
 5  1  3
 2  3  1

coxeter_matrix(W) or coxmat

returns the Coxeter matrix of the Coxeter group W, that is the matrix m whose entry m[i,j] contains the order of W(i)*W(j) where W(i) is the i-th Coxeter generator of W. An infinite order is represented by the entry 0.

julia> W=coxsym(4)
𝔖 ₄

julia> coxmat(W)
3×3 Matrix{Int64}:
 1  3  2
 3  1  3
 2  3  1

coxeter_symmetric_group(n::Integer) or coxeter_symmetric_group(m:n) or coxsym

The symmetric group on the letters 1:n (or if a m≤n is given, on the letters m:n) as a Coxeter group. The Coxeter generators are the Perm(i,i+1) for i in m:n-1.

julia> W=coxsym(3)
𝔖 ₃

julia> gens(W)
2-element Vector{Perm{Int16}}:
 (1,2)
 (2,3)

julia> e=elements(W)
6-element Vector{Perm{Int16}}:
 ()
 (1,2)
 (2,3)
 (1,3,2)
 (1,2,3)
 (1,3)

julia> length.(Ref(W),e) # length in the genrators of the elements
6-element Vector{Int64}:
 0
 1
 1
 2
 2
 3

firstleftdescent(W,w)

returns the index in gens(W) of the first element of the left descent set of w –- that is, the first i such that if s=W(i) then l(sw)<l(w). It returnsnothingforone(W)`.

julia> W=coxsym(3)
𝔖 ₃

julia> firstleftdescent(W,Perm(2,3))
2

inversions(W,w)

Returns the inversions of the element w of the finite Coxeter group W, that is, the list of the indices of reflections r of W such that l(rw)<l(w) where l is the Coxeter length.

julia> W=coxgroup(:A,3)
A₃

julia> inversions(W,W(1,2,1))
3-element Vector{Int64}:
 1
 2
 4

isleftdescent(W::CoxeterGroup,w,i::Integer)

returns true iff the i-th generating reflection of the Coxeter group W is in the left descent set of the element w of W, that is iff length(W,W(i)*w)<length(W,w).

julia> W=coxsym(3)
𝔖 ₃

julia> isleftdescent(W,Perm(1,2),1)
true

isrightdescent(W::CoxeterGroup,w,i::Integer)

returns true iff the i-th generating reflection of the Coxeter group W is in the right descent set of the element w of W, that is iff length(W,w*W(i))<length(W,w).

julia> W=coxsym(3)
𝔖 ₃

julia> isrightdescent(W,Perm(1,2),1)
true

leftdescents(W,w)

The left descents of the element w of the Coxeter group W, that is the set of i such that length(W,W(i)*w)<length(W,w).

julia> W=coxsym(3)
𝔖 ₃

julia> leftdescents(W,Perm(1,3))
2-element Vector{Int64}:
 1
 2

longest(W)

If W is finite, returns the unique element of maximal length of the Coxeter group W. May loop infinitely otherwise.

julia> longest(coxsym(4))
(1,4)(2,3)

longest(W,I)

returns the longest element of the parabolic subgroup of W generated by the generating reflections of indices in I.

julia> longest(coxsym(4))
(1,4)(2,3)

standard_parabolic_class(W,I)

I should be a subset of eachindex(gens(W)). The function returns the list of such subsets W-conjugate to I.

julia> CoxGroups.standard_parabolic_class(coxgroup(:E,8),[7,8])
7-element Vector{Vector{Int64}}:
 [7, 8]
 [6, 7]
 [5, 6]
 [4, 5]
 [2, 4]
 [3, 4]
 [1, 3]

cartan(W::CoxeterGroup) The Cartan matrix of W.

reflection_subgroup(W::CoxHyp,I) is defined only for I=1:m for m≤ngens(W).

reflection_subgroup(W::CoxSym,I)

The only reflection subgroups defined for coxsym(n) are for I=1:m for m≤n

elements(W::CoxeterGroup[,l])

When l is not given this works only if W is finite; it returns the elements of W sorted by increasing Coxeter length. If the second argument is an integer l, the elements of W of Coxeter length l are returned.

julia> W=coxgroup(:G,2)
G₂

julia> e=elements(W,6)
1-element Vector{Perm{Int16}}:
 (1,7)(2,8)(3,9)(4,10)(5,11)(6,12)

julia> e[1]==longest(W)
true

word(W::CoxeterGroup,w)

returns a reduced word in the standard generators of the Coxeter group W for the element w (represented as the vector of the corresponding generator indices).

julia> W=coxgroup(:A,3)
A₃

julia> w=perm"(1,11)(3,10)(4,9)(5,7)(6,12)"
(1,11)(3,10)(4,9)(5,7)(6,12)

julia> w in W
true

julia> word(W,w)
5-element Vector{Int64}:
 1
 2
 3
 2
 1

The result of  word is the lexicographically smallest reduced word for w (for the ordering of the Coxeter generators given by gens(W)).

words(W::CoxeterGroup[,l::Integer])

With one argument this works only if W is finite; it returns the reduced Coxeter words of elements of W by increasing length. If the second argument is an integer l, only the elements of length l are returned; this works for infinite Coxeter groups.

julia> W=coxgroup(:G,2)
G₂

julia> e=elements(W,6)
1-element Vector{Perm{Int16}}:
 (1,7)(2,8)(3,9)(4,10)(5,11)(6,12)

julia> e[1]==longest(W)
true

words(W::CoxeterGroup,w)

returns the list of all reduced expressions of the element w of the Coxeter group W.

julia> W=coxgroup(:A,3)
A₃

julia> words(W,longest(W))
16-element Vector{Vector{Int64}}:
 [1, 2, 1, 3, 2, 1]
 [1, 2, 3, 1, 2, 1]
 [1, 2, 3, 2, 1, 2]
 [1, 3, 2, 1, 3, 2]
 [1, 3, 2, 3, 1, 2]
 [2, 1, 2, 3, 2, 1]
 [2, 1, 3, 2, 1, 3]
 [2, 1, 3, 2, 3, 1]
 [2, 3, 1, 2, 1, 3]
 [2, 3, 1, 2, 3, 1]
 [2, 3, 2, 1, 2, 3]
 [3, 1, 2, 1, 3, 2]
 [3, 1, 2, 3, 1, 2]
 [3, 2, 1, 2, 3, 2]
 [3, 2, 1, 3, 2, 3]
 [3, 2, 3, 1, 2, 3]

reduced(H::CoxeterGroup,W::CoxeterGroup,i=nref(W))

The elements w∈ W which are H-reduced, and of length ≤i (by default all of them), grouped by length.

julia> W=coxgroup(:G,2)
G₂

julia> H=reflection_subgroup(W,[2,6])
G₂₍₂₆₎=Ã₁×A₁

julia> [word(W,w) for S in reduced(H,W) for w in S]
3-element Vector{Vector{Int64}}:
 []
 [1]
 [1, 2]

reduced(W,w)

The unique element of minimal length in the coset W.w. This makes sense when isleftdescent(W,u) makes sense for u∈ W.w which happens when w is a Coxeter automorphism of W or when w lives in a Coxeter overgroup of W.

julia> W=coxgroup(:G,2)
G₂

julia> H=reflection_subgroup(W,[2,6])
G₂₍₂₆₎=Ã₁×A₁

julia> word.(Ref(W),unique(reduced.(Ref(H),elements(W))))
3-element Vector{Vector{Int64}}:
 []
 [1]
 [1, 2]

Characters and conjugacy classes of complex reflection groups.

The CharTable of a finite complex reflection group W is computed using the decomposition of W in irreducible groups (see refltype). For each irreducible group the character table is either computed using recursive formulas for the infinite series, or read into the system from a library file for the exceptional types. Thus, character tables can be obtained quickly even for very large groups (e.g., E₈). Similar remarks apply for conjugacy classes.

The conjugacy classes and irreducible characters of irreducible finite complex reflection groups have canonical labelings by certain combinatorial objects; these labelings are used in the tables we give. For the classes, these are partitions or partition tuples for the infinite series, or, for exceptional Coxeter groups, Carter's admissible diagrams Carter1972; for other primitive complex reflection groups we just use words in the generators to specify the classes. For the characters, these are again partitions or partition tuples for the infinite series, and for the others they are pairs of two integers (d,e) where d is the degree of the character and e is the smallest symmetric power of the reflection representation containing the given character as a constituent (the b-invariant of the character). This information is given by the functions classinfo and charinfo. When you display the character table, the canonical labelings for classes and characters are displayed.

A typical example is coxgroup(:A,n), the symmetric group 𝔖ₙ₊₁ where classes and characters are parameterized by partitions of n+1 (this is also the case for coxsym(n+1)).

julia> W=coxgroup(:A,3)
A₃

julia> CharTable(W)
CharTable(A₃)
┌────┬─────────────────┐
│    │1111 211 22 31  4│
├────┼─────────────────┤
│1111│   1  -1  1  1 -1│
│211 │   3  -1 -1  .  1│
│22  │   2   .  2 -1  .│
│31  │   3   1 -1  . -1│
│4   │   1   1  1  1  1│
└────┴─────────────────┘

julia> W=coxgroup(:G,2)
G₂

julia> ct=CharTable(W)
CharTable(G₂)
┌─────┬────────────────────┐
│     │A₀ Ã₁ A₁ G₂ A₂ A₁+Ã₁│
├─────┼────────────────────┤
│φ₁‚₀ │ 1  1  1  1  1     1│
│φ₁‚₆ │ 1 -1 -1  1  1     1│
│φ′₁‚₃│ 1  1 -1 -1  1    -1│
│φ″₁‚₃│ 1 -1  1 -1  1    -1│
│φ₂‚₁ │ 2  .  .  1 -1    -2│
│φ₂‚₂ │ 2  .  . -1 -1     2│
└─────┴────────────────────┘

julia> ct.charnames
6-element Vector{String}:
 "\phi_{1,0}"
 "\phi_{1,6}"
 "\phi_{1,3}'"
 "\phi_{1,3}''"
 "\phi_{2,1}"
 "\phi_{2,2}"

julia> ct.classnames
6-element Vector{String}:
 "A_0"
 "\tilde A_1"
 "A_1"
 "G_2"
 "A_2"
 "A_1+\tilde A_1"

Reflection groups have fake degrees (see fakedegrees), whose valuation and degree give two integers b,B for each irreducible character of W. For spetsial groups (which include finite Coxeter groups), the valuation and degree of the generic degrees of the Hecke algebra give two more integers a,A (for Coxeter groups see Carter1985, Ch.11 for more details). These integers are also used in the operations of truncated induction, see j_induction_table and J_induction_table.

Iwahori-Hecke algebras and cyclotomic Hecke algebras also have character tables, see the corresponding chapters.

We now describe for each type our conventions for labeling the classes and characters.

Type Aₙ (n≥0). In this case we have W ≅ 𝔖ₙ₊₁. The classes and characters are labelled by partitions of n+1. The partition labelling a class is the cycle type of the elements in that class; the representative in '.classtext' is the concatenation of the words corresponding to each part, where the word for a part i is the product of i-1 consecutive generators (starting one higher than the last generator used for the previous parts). The partition labelling a character describes the type of the Young subgroup such that the trivial character induced from this subgroup contains that character with multiplicity 1 and such that every other character occurring in this induced character has a higher a-value. Thus, the sign character is labelled by the partition (1ⁿ⁺¹) and the trivial character by the partition (n+1). The character of the reflection representation of W is labelled by (n,1).

Type Bₙ (n≥2). In this case W=W(Bₙ) is isomorphic to the wreath product of the cyclic group of order 2 with the symmetric group 𝔖ₙ. Hence the classes and characters are parameterized by pairs of partitions such that the total sum of their parts equals n. The pair corresponding to a class describes the signed cycle type for the elements in that class, as in Carter1972. We use the convention that if (λ,μ) is such a pair then λ corresponds to the positive and μ to the negative cycles. Thus, (1ⁿ,-) and (-,1ⁿ) label respectively the trivial class and the class of the longest element.

The pair corresponding to an irreducible character is determined via Clifford theory, as follows. We have a semidirect product decomposition W(Bₙ)=N ⋊ 𝔖ₙ where N is the standard n-dimensional 𝔽₂ⁿ-vector space. For a,b ≥ 0 such that n=a+b let $η_{a,b}$ be the irreducible character of N which takes value 1 on the first a standard basis vectors and value -1 on the last b standard basis vectors of N. Then the inertia subgroup of $η_{a,b}$ has the form $T_{a,b}=N.(𝔖_a × 𝔖_b)$ and we can extend $η_{a,b}$ trivially to an irreducible character $η̃_{a,b}$ of $T_{a,b}$. Let α and β be partitions of a and b, respectively. We take the tensor product of the corresponding irreducible characters of 𝔖_a and 𝔖_b and regard this as an irreducible character of $T_{a,b}$. Multiplying this character with $η̃_{a,b}$ and inducing to W(Bₙ) yields an irreducible character $χ= χ_{(α,β)}$ of W(Bₙ). This defines the correspondence between irreducible characters and pairs of partitions as above.

For example, the pair ((n),-) labels the trivial character and (-,(1ⁿ)) labels the sign character. The character of the natural reflection representation is labeled by ((n-1),(1)).

Type Dₙ (n≥4). In this case W=W(Dₙ) can be embedded as a subgroup of index 2 into the Coxeter group W(Bₙ). The intersection of a class of W(Bₙ) with W(Dₙ) is either empty or a single class in W(Dₙ) or splits up into two classes in W(Dₙ). This also leads to a parameterization of the classes of W(Dₙ) by pairs of partitions (λ,μ) as before but where the number of parts of μ is even and where there are two classes of this type if μ is empty and all parts of λ are even. In the latter case we denote the two classes in W(Dₙ) by (λ,+) and (λ,-), where we use the convention that the class labeled by (λ,+) contains a representative which can be written as a word in {s₁,s₃,…,sₙ} and (λ,-) contains a representative which can be written as a word in {s₂,s₃, …,sₙ}.

By Clifford theory the restriction of an irreducible character of W(Bₙ) to W(Dₙ) is either irreducible or splits up into two irreducible components. Let (α,β) be a pair of partitions with total sum of parts equal to n. If α!=β then the restrictions of the irreducible characters of W(Bₙ) labeled by (α,β) and (β,α) are irreducible and equal. If α=β then the restriction of the character labeled by (α,α) splits into two irreducible components which we denote by (α,+) and (α,-). Note that this can only happen if n is even. In order to fix the notation we use a result of Stembridge1989 which describes the value of the difference of these two characters on a class of the form (λ,+) in terms of the character values of the symmetric group 𝔖_{n/2}. Recall that it is implicit in the notation (λ,+) that all parts of λ are even. Let λ' be the partition of n/2 obtained by dividing each part by 2. Then the value of χ_{(α,-)}-χ_{(α,+)} on an element in the class (λ,+) is given by 2^{k(λ)} times the value of the irreducible character of 𝔖_{n/2} labeled by α on the class of cycle type λ'. (Here, k(λ) denotes the number of non-zero parts of λ.)

The labels for the trivial, the sign and the natural reflection character are the same as for W(Bₙ), since these characters are restrictions of the corresponding characters of W(Bₙ).

The groups G(d,1,n). They are isomorphic to the wreath product of the cyclic group of order d with the symmetric group 𝔖ₙ. Hence the classes and characters are parameterized by d-tuples of partitions such that the total sum of their parts equals n. The words chosen as representatives of the classes are, when d>2, computed in a slightly different way than for Bₙ, in order to agree with the words on which Ram and Halverson compute the characters of the Hecke algebra. First the parts of the d partitions are merged in one big partition and sorted in increasing order. Then, to a part i coming from the j-th partition is associated the word (l+1…1… l+1)ʲ⁻¹l+2…l+i where l is the highest generator used to express the previous part.

The d-tuple corresponding to an irreducible character is determined via Clifford theory in a similar way than for the Bₙ case. The identity character has the first partition with one part equal n and the other ones empty. The character of the reflection representations has the first two partitions with one part equal respectively to n-1 and to 1, and the other partitions empty.

The groups G(de,e,n). They are normal subgroups of index e in G(de,1,n). The quotient is cyclic, generated by the image g of the first generator of G(de,1,n). The classes are parameterized as the classes of G(de,e,n) with an extra information for a component of a class which splits.

According to Hugues1985, a class C of G(de,1,n) parameterized by a de-partition $(S₀,…,S_{de-1})$ is in G(de,e,n) if e divides $∑ᵢ i ∑_{p∈ Sᵢ}p$. It splits in d classes for the largest d dividing e and all parts of all Sᵢ and such that Sᵢ is empty if d does not divide i. If w is in C then 'gⁱ w g⁻ⁱ' for 'i in 0:d-1' are representatives of the classes of G(de,e,n) which meet C. They are described by appending the integer i to the label for C.

The characters are described by Clifford theory. We make g act on labels for characters of G(de,1,n) . The action of g permutes circularly by d the partitions in the de-tuple. A character has same restriction to G(de,e,n) as its transform by g. The number of irreducible components of its restriction is equal to the order k of its stabilizer under powers of g. We encode a character of G(de,e,n) by first, choosing the smallest for lexicographical order label of a character whose restriction contains it; then this label is periodic with a motive repeated k times; we represent the character by one of these motives, to which we append E(k)ⁱ for 'i in 0:k-1' to describe which component of the restriction we choose.

Types G₂ and F₄. The matrices of character values and the orderings and labelings of the irreducible characters are exactly the same as in Carter1985, p.412/413: in type G₂ the character φ₁,₃' takes the value -1 on the reflection associated to the long simple root; in type F₄, the characters φ₁,₁₂', φ₂,₄', φ₄,₇', φ₈,₉' and φ₉,₆' occur in the induced of the identity from the A₂ corresponding to the short simple roots; the pairs (φ₂,₁₆', φ₂,₄″) and (φ₈,₃', φ₈,₉″) are related by tensoring by sign; and finally φ₆,₆″ is the exterior square of the reflection representation. Note, however, that we put the long root at the left of the Dynkin diagrams to be in accordance with the conventions in Lusztig1985, (4.8) and (4.10).

The classes are labeled by Carter's admissible diagrams Carter1972. A character is labeled by a pair (d,b) where d denotes the degree and b the corresponding b-invariant. If there are several characters with the same pair (d,b) we attach a prime to them, as in Carter1985.

Types E₆,E₇,E₈. The character tables are obtained by specialization of those of the Hecke algebra. The classes are labeled by Carter's admissible diagrams Carter1972. A character is labeled by the pair (d,b) where d denotes the degree and b is the corresponding b-invariant. For these types, this gives a unique labeling of the characters.

Non-crystallographic types I₂(m), H₃, H₄. In these cases we do not have canonical labelings for the classes. We label them by reduced expressions.

Each character for type H₃ is uniquely determined by the pair (d,b) where d is the degree and b the corresponding b-invariant. For type H₄ there are just two characters (those of degree 30) for which the corresponding pairs are the same. These two characters are nevertheless distinguished by their fake degrees: the character φ₃₀,₁₀' has fake degree q¹⁰+q¹²+ higher terms, while φ₃₀,₁₀″ has fake degree q¹⁰+q¹⁴+ higher terms. The characters in the table for type H₄ are ordered in the same way as in Alvis and Lusztig1982.

Finally, the characters of degree 2 for type I₂(m) are ordered as follows. The matrix representations affording the characters of degree 2 are given by: $ρ_j : s₁s₂ ↦ \begin{pmatrix}\zeta_m^j&0\\0&\zeta_m^{-j}\end{pmatrix}, s₁↦\begin{pmatrix}0&1\\1&0\end{pmatrix},$ where 1 ≤ j ≤ ⌊(m-1)/2⌋. The reflection representation is ρ₁. The characters in the table are ordered by listing first the characters of degree 1 and then ρ₁,ρ₂,….

Primitive complex reflection groups G₄ to G₃₄. The groups G₂₃=H₃, G₂₈=F₄, G₃₀=H₄ are exceptional Coxeter groups and have been explained above. Similarly for the other groups labels for characters consist primarily of the pair (d,b) where d denotes the degree and b is the corresponding b-invariant. This is sufficient for G₄, G₁₂, G₂₂ and G₂₄. For other groups there are pairs or triples of characters which have the same (d,b) value. We disambiguate these according to the conventions of Malle2000 for G₂₇, G₂₉, G₃₁, G₃₃ and G₃₄:

• For G₂₇:

The fake degree of φ₃,₅' (resp. φ₃,₂₀', φ₈,₉″) has smaller degree that of φ₃,₅″ (resp. φ₃,₂₀″, φ₈,₉'). The characters φ₅,₁₅' and φ₅,₆' occur with multiplicity 1 in the induced from the trivial character of the parabolic subgroup of type A₂ generated by the first and third generator (it is asserted mistakenly in Malle2000 that φ₅,₆″ does not occur in this induced; it occurs with multiplicity 2).

• For G₂₉:

The character φ₆,₁₀‴ is the exterior square of φ₄,₁; its complex conjugate is φ₆,₁₀⁗. The character φ₁₅,₄″ occurs in φ₄,₁⊗φ₄,₃; the character φ₁₅,₁₂″ is tensored by the sign character from φ₁₅,₄″. Finally φ₆,₁₀' occurs in the induced from the trivial character of the standard parabolic subgroup of type A₃ generated by the first, second and fourth generators.

• For G₃₁:

The characters φ₁₅,₈', φ₁₅,₂₀' and φ₄₅,₈″ occur in φ₄,₁⊗φ₂₀,₇; the character φ₂₀,₁₃' is complex conjugate of φ₂₀,₇; the character φ₄₅,₁₂' is tensored by sign of φ₄₅,₈'. The two terms of maximal degree of the fakedegree of φ₃₀,₁₀' are q⁵⁰+q⁴⁶ while for φ₃₀,₁₀″ they are q⁵⁰+2q⁴⁶.

• For G₃₃:

The two terms of maximal degree of the fakedegree of φ₁₀,₈' are q²⁸+q²⁶ while for φ₁₀,₈″ they are q²⁸+q²⁴. The terms of maximal degree of the fakedegree of φ₄₀,₅' are q³¹+q²⁹ while for φ₄₀,₅″ they are q³¹+2q²⁹. The character φ₁₀,₁₇' is tensored by sign of φ₁₀,₈' and φ₄₀,₁₄' is tensored by sign of φ₄₀,₅'.

• For G₃₄:

The character φ₂₀,₃₃' occurs in φ₆,₁⊗φ₁₅,₁₄. The character φ₇₀,₉' is rational. The character φ₇₀,₉″ occurs in φ₆,₁⊗φ₁₅,₁₄. The character φ₇₀,₄₅' is rational.The character φ₇₀,₄₅″ is tensored by the determinant character of φ₇₀,₉″. The character φ₅₆₀,₁₈' is rational. The character φ₅₆₀,₁₈‴ occurs in φ₆,₁⊗φ₃₃₆,₁₇. The character φ₂₈₀,₁₂' occurs in φ₆,₁⊗φ₃₃₆,₁₇. The character φ₂₈₀,₃₀″ occurs in φ₆,₁⊗φ₃₃₆,₁₇. The character φ₅₄₀,₂₁' occurs in φ₆,₁⊗φ₁₀₅,₂₀. The character φ₁₀₅,₈' is complex conjugate of φ₁₀₅,₄, and φ₈₄₀,₁₃' is complex conjugate of φ₈₄₀,₁₁. The character φ₈₄₀,₂₃' is complex conjugate of φ₈₄₀,₁₉. Finally φ₁₂₀,₂₁' occurs in induced from the trivial character of the standard parabolic subgroup of type A₅ generated by the generators of G₃₄ with the third one omitted.

For the groups G₅ and G₇ we adopt the following conventions. For G₅ they are compatible with those of MalleRouquier2003 and BroueMalleMichel2014.

• For G₅:

We let W=complex_reflection_group(5), so the generators are W(1) and W(2).

The character φ₁,₄' (resp. φ₁,₁₂', φ₂,₃') takes the value 1 (resp. ζ₃, -ζ₃) on W(1). The character φ₁,₈″ is complex conjugate to φ₁,₁₆, and the character φ₁,₈' is complex conjugate to φ₁,₄' . The character φ₂,₅″ is complex conjugate to φ₂,₁; φ₂,₅' takes the value -1 on W(1). The character φ₂,₇' is complex conjugate to φ₂,₅'.

• For G₇:

We let W=complex_reflection_group(7), so the generators are W(1), W(2) and W(3).

The characters φ₁,₄' and φ₁,₁₀' take the value 1 on W(2). The character φ₁,₈″ is complex conjugate to φ₁,₁₆ and φ₁,₈' is complex conjugate to φ₁,₄'. The characters φ₁,₁₂' and φ₁,₁₈' take the value ζ₃ on W(2). The character φ₁,₁₄″ is complex conjugate to φ₁,₂₂ and φ₁,₁₄' is complex conjugate to φ₁,₁₀'. The character φ₂,₃' takes the value -ζ₃ on W(2) and φ₂,₁₃' takes the value -1 on W(2). The characters φ₂,₁₁″, φ₂,₅″, φ₂,₇‴ and φ₂,₁ are Galois conjugate, as well as the characters φ₂,₇', φ₂,₁₃', φ₂,₁₁' and φ₂,₅'. The character φ₂,₉' is complex conjugate to φ₂,₁₅ and φ₂,₉‴ is complex conjugate to φ₂,₃'.

Finally, for the remaining groups G₆, G₈ to G₁₁, G₁₃ to G₂₁, G₂₅, G₂₆, G₃₂ and G₃₃ there are only pairs of characters with same value (d,b). We give labels uniformly to these characters by applying in order the following rules :

• If the two characters have different fake degrees, label φ_{d,b}' the one whose fake degree is minimal for the lexicographic order of polynomials (starting with the highest term).

• For the not yet labeled pairs, if only one of the two characters has the property that in its Galois orbit at least one character is distinguished by its (d,b)-invariant, label it φ_{d,b}'.

• For the not yet labeled pairs, if the minimum of the (d,b)-value (for the lexicographic order (d,b)) in the Galois orbits of the two character is different, label φ_{d,b}' the character with the minimal minimum.

• We define now a new invariant for characters: consider all the pairs of irreducible characters χ and ψ uniquely determined by their (d,b)-invariant such that φ occurs with non-zero multiplicity m in χ⊗ψ. We define t(φ) to be the minimal (for lexicographic order) possible list (d(χ),b(χ),d(ψ),b(ψ),m).

For the not yet labeled pairs, if the t-invariants are different, label φ_{d,b}' the character with the minimal t-invariant.

After applying the last rule all the pairs will be labelled for the considered groups. The labelling obtained is compatible for G₂₅, G₂₆, G₃₂ and G₃₃ with that of Malle2000 and for G₈ with that described in MalleRouquier2003.

We should emphasize that for all groups with a few exceptions, the parameters for characters do not depend on any non-canonical choice. The exceptions are G(de,e,n) with e>1, and G₅, G₇, G₂₇, G₂₈, G₂₉ and G₃₄, groups which admit outer automorphisms preserving the set of reflections, so choices of a particular value on a particular generator must be made for characters which are not invariant by these automorphisms.

Labels for the classes. For the exceptional complex reflection groups, the labels for the classes represent the decomposition of a representative of the class as a product of generators, with the additional conventions that 'z' represents the generator of the center and for well-generated groups 'c' represents a Coxeter element (a product of the generators which is a regular element for the highest reflection degree).

CharTable is a structure to hold character tables of groups and Hecke algebras

CharTable(WF::Spets)

This function returns the character table of the reflection coset WF. We call characters of the coset WF=W.ϕ of the group W the restriction to W.ϕ of a set containing one extension of each ϕ-invariant character of W to the semidirect product of W with the cyclic group generated by ϕ (for Coxeter cosets we choose, following Lusztig, in each case one extension, called the preferred extension.)

julia> W=spets(coxgroup(:D,4),Perm(1,2,4))
³D₄

julia> CharTable(W)
CharTable(³D₄)
┌─────┬─────────────────────────────────┐
│     │C₃ Ã₂ C₃+A₁ Ã₂+A₁ F₄ Ã₂+A₂ F₄(a₁)│
├─────┼─────────────────────────────────┤
│.4   │ 1  1     1     1  1     1      1│
│.1111│-1  1     1    -1  1     1      1│
│.22  │ .  2     2     . -1    -1     -1│
│11.2 │ .  .     .     . -1     3      3│
│1.3  │ 1  1    -1    -1  .    -2      2│
│1.111│-1  1    -1     1  .    -2      2│
│1.21 │ .  2    -2     .  .     2     -2│
└─────┴─────────────────────────────────┘

J_induction_table(H, W)

computes the decomposition into irreducible characters of the reflection group W of the J-induced of the irreducible characters of the reflection subgroup H. The J-induced of φ is the sum of the irreducible components of the induced of φ which have same a-function (see charinfo) as φ. What is returned is an InductionTable struct.

julia> W=coxgroup(:D,4)
D₄

julia> H=reflection_subgroup(W,[1,3])
D₄₍₁₃₎=A₂Φ₁²

julia> J_induction_table(H,W)
J-induction table from D₄₍₁₃₎=A₂Φ₁² to D₄
┌─────┬────────┐
│     │111 21 3│
├─────┼────────┤
│11+  │  .  . .│
│11-  │  .  . .│
│1.111│  .  . .│
│.1111│  .  . .│
│11.2 │  1  . .│
│1.21 │  1  . .│
│.211 │  .  . .│
│2+   │  .  . .│
│2-   │  .  . .│
│.22  │  .  . .│
│1.3  │  .  1 .│
│.31  │  .  . .│
│.4   │  .  . 1│
└─────┴────────┘

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]

charinfo(W)

returns information about the irreducible characters of the finite reflection group or Spets W. The result is an object with various entries describing properties of the irreducible characters of W. This object prints at the Repl or in Pluto or Jupyter as a table synthesizing most information.

A field not in the table is .charparams: it contains parameters for the irreducible characters. A parameter is a list with one item for each irreducible component of W (as given by refltype). For an irreducible W see the helpstring for Chars for what are the parameters.

julia> charinfo(coxgroup(:G,2)).charparams
6-element Vector{Vector{Vector{Int64}}}:
 [[1, 0]]
 [[1, 6]]
 [[1, 3, 1]]
 [[1, 3, 2]]
 [[2, 1]]
 [[2, 2]]

julia> charinfo(coxgroup(:G,2))
┌──┬──────────────────────────────────────────────────────────┐
│n0│ name ext b B a A spaltenstein lusztig              symbol│
├──┼──────────────────────────────────────────────────────────┤
│1 │ φ₁‚₀  Id 0 0 0 0            1       1       (0,0,0,0,0,2)│
│2 │ φ₁‚₆ det 6 6 6 6            ε       ε (01,01,01,01,01,12)│
│3 │φ′₁‚₃     3 3 1 5           εₗ      ε′            (0,0,1+)│
│4 │φ″₁‚₃     3 3 1 5          ε_c      ε″            (0,0,1-)│
│5 │ φ₂‚₁  Λ¹ 1 5 1 5           θ′      θ′       (0,0,0,0,1,1)│
│6 │ φ₂‚₂     2 4 1 5           θ″      θ″       (0,0,0,1,0,1)│
└──┴──────────────────────────────────────────────────────────┘

In the table printed at the Repl, the columns reflect various fields of charinfo. The column name reflects the field .charnames, a name computed from .charparams. This is the same as charnames(io,W) where here io being the Repl has the property :limit true.

The column ext shows the exterior powers of the reflection representation. It corresponds to the field .extrefl which is present only if W is irreducible. Otherwise, only two items are shown in the column: Id corresponds to the field .positionId and shows the trivial character. det corresponds to the field .positionDet and shows the determinant character (for Coxeter groups the sign character). When W is irreducible, the characters marked Λⁱ are the i-th exterior power of the reflection representation. They are irreducible by a theorem of Steinberg.

The column b shows the field .b listing for each character the valuation of the fake degree, and the column B shows the field .B, the degree of the fake degree.

The columns a and A only appear for Spetsial groups. They correspond then to the fields .a and .A, and contain respectively the valuation and the degree of the generic degree of the character (in the one-parameter Hecke algebra hecke(W,Pol()) for W).

For irreducible groups, the table shows sometimes additional columns, corresponding to a field of the same name.

for F₄, the column kondo gives the labeling of the characters given by Kondo, also used in Lusztig1985, (4.10).

for E₆, E₇, E₈ the column frame gives the labeling of the characters given by Frame, also used in Lusztig1985, (4.11), (4.12), and (4.13).

for G₂ the column spaltenstein gives the labeling of the characters given by Spaltenstein.

for G(de,e,2) even e and d>1, the column malle gives the parameters for the characters used in Malle1996.

If W is irreducible spetsial and imprimitive, the column 'symbol(corresponding to the field.charSymbols`) shows the symbol attached to the corresponding unipotent caracter.

If W isa Spets, the column restr. (corresponding to the field .charRestrictions) gives the number of the corresponding character of Group(W).

Finally, the field .hgal contains the permutation of the characters resulting from a Galois action on the characters of H=hecke(W,Pol()^e) where e is the order of the center of W. H splits by taking v an e-th root of Pol(), and .hgal records the permutation effected by the Galois action v->E(e)*v (charinfo does not have the key :hgal if this permutation is trivial). .hgal*conj, where conj is the complex conjugaison, is the Opdam involution.

julia> charinfo(complex_reflection_group(24))
┌──┬─────────────────────┐
│n0│ name ext  b  B  a  A│
├──┼─────────────────────┤
│1 │ φ₁‚₀  Id  0  0  0  0│
│2 │φ₁‚₂₁ det 21 21 21 21│
│3 │ φ₃‚₈      8 18  8 20│
│4 │ φ₃‚₁  Λ¹  1 11  1 13│
│5 │φ₃‚₁₀  Λ² 10 20  8 20│
│6 │ φ₃‚₃      3 13  1 13│
│7 │ φ₆‚₂      2 12  1 13│
│8 │ φ₆‚₉      9 19  8 20│
│9 │ φ₇‚₆      6 18  6 18│
│10│ φ₇‚₃      3 15  3 15│
│11│ φ₈‚₄      4 16  4 17│
│12│ φ₈‚₅      5 17  4 17│
└──┴─────────────────────┘
hgal=(11,12)

charnames(ComplexReflectionGroup or Spets;options...) charnames(io::IO,ComplexReflectionGroup or Spets)

returns the list of character names for the reflection group or Spets W. The options may imply alternative names in certain cases, or a different formatting of names in general. They can be specified by IO attributes if giving an IO as argument.

julia> W=coxgroup(:G,2)
G₂

julia> charnames(W;limit=true)
6-element Vector{String}:
 "φ₁‚₀"
 "φ₁‚₆"
 "φ′₁‚₃"
 "φ″₁‚₃"
 "φ₂‚₁"
 "φ₂‚₂"

julia> charnames(W;TeX=true)
6-element Vector{String}:
 "\phi_{1,0}"
 "\phi_{1,6}"
 "\phi_{1,3}'"
 "\phi_{1,3}''"
 "\phi_{2,1}"
 "\phi_{2,2}"

julia> charnames(W;spaltenstein=true,limit=true)
6-element Vector{String}:
 "1"
 "ε"
 "εₗ"
 "ε_c"
 "θ′"
 "θ″"

julia> charnames(W;spaltenstein=true,TeX=true)
6-element Vector{String}:
 "1"
 "\varepsilon"
 "\varepsilon_l"
 "\varepsilon_c"
 "\theta'"
 "\theta''"

The last two commands show the character names used by Spaltenstein and Lusztig when describing the Springer correspondence.

classinfo(W)

returns information about the conjugacy classes of the finite reflection group or Spets W. The result is an object with various entries describing properties of the conjugacy classes of W. This object prints at the Repl or in Pluto or Jupyter as a table synthesizing most information.

A field not in the table is .classparams, containing parameters for the conjugacy classes. Each parameter is a vector which has one item for each irreducible component of W. For what are the parameters for an irreducible W, see the helpstring of Chars.

julia> classinfo(coxgroup(:A,2))
┌──┬──────────────────────┐
│n0│name length order word│
├──┼──────────────────────┤
│1 │ 111      1     1    .│
│2 │  21      3     2    1│
│3 │   3      2     3   12│
└──┴──────────────────────┘

The table contains the columns:

• name, corresponding to the field .classnames: strings describing the conjugacy classes, made out of the information in :classparams.
• length, corresponding to the field .classes, is the number of elements in the conjugacy class.
• order, corresponding to the field .orders, is the order of elements in the conjugacy class.
• word, corresponding to the field .classtext, describes a word in the generators for the representatives of each conjugacy class. Each word is a list of integers where the generator W(i) is represented by the integer i. For finite Coxeter groups, it is the same as word.(Ref(W),classreps(W)), and each such representative is of minimal length in its conjugacy class and is a "very good" element in the sense of GeckMichel1997.

classnames(W;options...) classnames(io::IO,W)

returns the list of class names for the reflection group W. The optional options are IOContext attributes which can give alternative names in certain cases, or a different formatting of names in general. They can be specified by giving an IO as argument.

conjPerm(W)

return the permutation of the characters of the group W which is effected when taking the complex conjugate of the character table.

julia> W=complex_reflection_group(4)
G₄

julia> conjPerm(W)
(2,3)(5,6)

decompose(ct::CharTable,c::Vector;exact=true)

decompose class function c (given by its values on conjugacy classes) on irreducible characters as given by CharTable ct. By default c is expected to be a virtual character so the result will be an integer vector. If c is not a virtual character give the keyword exact=false to get a correct result.

decomposition_matrix(W,p)

This provides an interface to some decomposition matrices for Weyl groups available in the Chevie library: those for E₆, E₇, E₈ for p=2,3,5,7.

detPerm(W)

return the permutation of the characters of the reflection group W which is effected when tensoring by the determinant character (for Coxeter groups this is the sign character).

julia> W=coxgroup(:D,4)
D₄

julia> detPerm(W)
(1,8)(2,9)(3,11)(4,13)(7,12)

fakedegree(W, φ, q=Pol())

returns the fake degree (see fakedegrees for a definition) of the character of parameter φ (see charinfo(W).charparams) of the reflection group W, evaluated at q .

julia> fakedegree(coxgroup(:A,2),[[2,1]],Pol(:q))
Pol{Cyc{Int64}}: q²+q

fakedegrees(W, q=Pol())

returns a list holding the fake degrees of the reflection group W on the vector space V, evaluated at q. These are the graded multiplicities of the irreducible characters of W in the quotient SV/I where SV is the symmetric algebra of V and I is the ideal generated by the homogeneous invariants of positive degree in SV. The ordering of the result corresponds to the ordering of the characters in charinfo(W).

julia> fakedegrees(coxgroup(:A,2),Pol(:q))
3-element Vector{Pol{Int64}}:
 q³
 q²+q
 1

induction_table(u,g)

returns an object describing the decomposition of the irreducible characters of the subgroup u induced to the group g. At the repl or IJulia or Pluto, a table is displayed where the rows correspond to the characters of the parent group, and the columns to those of the subgroup. The returned object has a field scalar which is a Matrix{Int} containing the induction table, and the other fields contain labeling information taken from the character tables of u and g when it exists.

julia> g=Group([Perm(1,2),Perm(2,3),Perm(3,4)])
Group([(1,2),(2,3),(3,4)])

julia> u=Group( [ Perm(1,2), Perm(3,4) ])
Group([(1,2),(3,4)])

julia> induction_table(u,g)  #     needs "using GAP"
Induction table from Group((1,2),(3,4)) to Group((1,2),(2,3),(3,4))
┌───┬───────────────┐
│   │X.1 X.2 X.3 X.4│
├───┼───────────────┤
│X.1│  .   1   .   .│
│X.2│  .   1   1   1│
│X.3│  1   1   .   .│
│X.4│  1   .   1   1│
│X.5│  1   .   .   .│
└───┴───────────────┘

julia> g=coxgroup(:G,2)
G₂

julia> u=reflection_subgroup(g,[1,6])
G₂₍₁₅₎=A₂

julia> t=induction_table(u,g)
Induction table from G₂₍₁₅₎=A₂ to G₂
┌─────┬────────┐
│     │111 21 3│
├─────┼────────┤
│φ₁‚₀ │  .  . 1│
│φ₁‚₆ │  1  . .│
│φ′₁‚₃│  1  . .│
│φ″₁‚₃│  .  . 1│
│φ₂‚₁ │  .  1 .│
│φ₂‚₂ │  .  1 .│
└─────┴────────┘

IO attributes can be transmitted to the table format method

julia> xdisplay(t;rows=[5],cols=[3,2])
Induction table from G₂₍₁₅₎=A₂ to G₂
┌─────┬────┐
│     │3 21│
├─────┼────┤
│φ₂‚₁ │.  1│
└─────┴────┘

It is also possible to TeX induction tables with xdisplay(t;TeX=true).

induction_table also works for spets (reflection cosets).

j_induction_table(H, W)

computes the decomposition into irreducible characters of the reflection group W of the j-induced of the irreducible characters of the reflection subgroup H. The j-induced of φ is the sum of the irreducible components of the induced of φ which have same b-function (see charinfo) as φ. What is returned is an InductionTable struct.

julia> W=coxgroup(:D,4)
D₄

julia> H=reflection_subgroup(W,[1,3])
D₄₍₁₃₎=A₂Φ₁²

julia> j_induction_table(H,W)
j-induction table from D₄₍₁₃₎=A₂Φ₁² to D₄
┌─────┬────────┐
│     │111 21 3│
├─────┼────────┤
│11+  │  .  . .│
│11-  │  .  . .│
│1.111│  .  . .│
│.1111│  .  . .│
│11.2 │  .  . .│
│1.21 │  1  . .│
│.211 │  .  . .│
│2+   │  .  . .│
│2-   │  .  . .│
│.22  │  .  . .│
│1.3  │  .  1 .│
│.31  │  .  . .│
│.4   │  .  . 1│
└─────┴────────┘

on_chars(G,aut)

aut is an automorphism of the group G (for a permutation group, this could be given as a permutation normalizing G). The result is the permutation of the indices of the irreducible characters induced by aut.

julia> WF=rootdatum("3D4")
³D₄

julia> on_chars(Group(WF),WF.phi)
(1,2,7)(8,9,12)

representation(W,i)

returns, for the i-th irreducible representation of the complex reflection group or Spets W, a list of matrices images of the generating reflections of W in a model of the representation (for Spets, the result is a NamedTuple with fields gens, a representation of Group(W), and F, the matrix for W.phi in the representation). This function is based on the classification, and is not yet fully implemented for G₃₄; 78 representations are missing out of 169, that is, representations of dimension ≥140, except half of those of dimensions 315, 420 and 840.

julia> representation(complex_reflection_group(24),3)
3-element Vector{Matrix{Cyc{Int64}}}:
 [1 0 0; -1 -1 0; -1 0 -1]
 [-1 0 -1; 0 -1 (1-√-7)/2; 0 0 1]
 [-1 -1 0; 0 1 0; 0 (1+√-7)/2 -1]

representations(W)

returns the list of representations of the complex reflection group or Spets W (see representation).

julia> representations(coxgroup(:B,2))
5-element Vector{Vector{Matrix{Int64}}}:
 [[1;;], [-1;;]]
 [[1 0; -1 -1], [1 2; 0 -1]]
 [[-1;;], [-1;;]]
 [[1;;], [1;;]]
 [[-1;;], [1;;]]

schur_functor(mat,l)

mat should be a square matrix and l a partition. The result is the Schur functor of the matrix mat corresponding to partition l; for example, if l==[n] it returns the n-th symmetric power and if l==[1,1,1] it returns the 3rd exterior power. The current algorithm (from Littlewood) is rather inefficient so it is quite slow for partitions of n where n>6.

julia> m=cartan(:A,3)
3×3 Matrix{Int64}:
  2  -1   0
 -1   2  -1
  0  -1   2

julia> schur_functor(m,[2,2])
6×6 Matrix{Rational{Int64}}:
   9   -6    4  3//2   -2    1
 -12   16  -16  -4      8   -4
   4   -8   16   2     -8    4
  12  -16   16  10    -16   12
  -4    8  -16  -4     16  -12
   1   -2    4  3//2   -6    9

discriminant(W)

returns the discriminant of the complex reflection group W, as a polynomial in the fundamental invariants. The discriminant is the invariant obtained by taking the product of the linear forms describing the reflecting hyperplanes of W, each raised to the order of the corresponding reflection. The discriminant is returned as a function f such that the discriminant in the variables a₁,…,aₙ is obtained by calling f(a₁,…,aₙ). For the moment, this function is implemented only for the exceptional complex reflection groups G₄ to G₃₃.

julia> W=complex_reflection_group(4);@Mvp x,y

julia> discriminant(W)(x,y)
Mvp{Int64}: x³-y²

chevieget(t,w) returns CHEVIE[Symbol(t)][w]

getchev(t::TypeIrred,f::Symbol,extra...) get CHEVIE[field(t)][f](extra...)

This module Murphy.jl has been ported in december 2020 from

murphy.g Copyright (C) July 1998 Andrew Mathas mathas@maths.usyd.edu.au University of Sydney

It allows computations with the Murphy basis of an Hecke algebra of type A.

Multiplication of Murphy basis elements is done using the Garnir tableaux as described in Murphy's paper Mur1995. This also lets us convert from the T-basis to the Murphy basis since T_w = M([[1],…,[n]], [[1],…,[n]]) * T_w. (We use "M" for the Murphy basis).

As with the T-basis, Murphy basis elements are implemented by ModuleElts. Here the keys are standard tableaux pairs. These are represented by a tuple (mu,s,t) where mu, s and t are all integers and H.Murphy.partitions[mu] is the associated partition and H.Murphy.tableaux[mu][s] (resp t) is a named tuple describing s (this tuple is described in the function initMurphy() below).

Throughout memory considerations are thrown to the wind as we cache many of the more horrible expansions as we go along in order to save time when we next need them.

Set Murphy.SpechtModules[]=true to work just inside the Specht modules. This makes computations with the Murphy basis inside Specht modules modules much faster but also means that T to Murphy basis conversions do not work, even if Murphy.SpechtModules[]=false is set later.

Families of unipotent characters

The blocks of the (rectangular) matrix $⟨Rᵪ,ρ⟩_{𝐆 ^F}$ when χ runs over Irr(W) and ρ runs over the unipotent characters, are called the Lusztig families. When 𝐆 is split and W is a Coxeter group they correspond on the Irr(W) side to two-sided Kazhdan-Lusztig cells –- for split Spetses they correspond to Rouquier blocks of the Spetsial Hecke algebra. The matrix of scalar products $⟨Rᵪ,ρ⟩_{𝐆 ^F}$ can be completed to a square matrix $⟨A_{ρ'},ρ⟩_{𝐆 ^F}$ where $A_{ρ'}$ are the characteristic functions of character sheaves on $𝐆 ^F$; this square matrix is called the Fourier matrix of the family.

The 'UnipotentCharacters' record in Chevie contains a field '.families', a list of family records containing information on each family, including the Fourier matrix. Here is an example.

julia> W=coxgroup(:G,2)
G₂

julia> uc=UnipotentCharacters(W);

julia> uc.families
3-element Vector{Family}:
 Family(D(𝔖 ₃),[5, 6, 4, 3, 8, 7, 9, 10])
 Family(C₁,[1])
 Family(C₁,[2])

julia> uc.families[1]
Family(D(𝔖 ₃),[5, 6, 4, 3, 8, 7, 9, 10])
Drinfeld double of 𝔖 ₃, Lusztig′s version
┌────────┬────────────────────────────────────────────────────┐
│label   │eigen                                               │
├────────┼────────────────────────────────────────────────────┤
│(1,1)   │    1 1//6  1//2  1//3  1//3  1//6  1//2  1//3  1//3│
│(g₂,1)  │    1 1//2  1//2     .     . -1//2 -1//2     .     .│
│(g₃,1)  │    1 1//3     .  2//3 -1//3  1//3     . -1//3 -1//3│
│(1,ρ)   │    1 1//3     . -1//3  2//3  1//3     . -1//3 -1//3│
│(1,ε)   │    1 1//6 -1//2  1//3  1//3  1//6 -1//2  1//3  1//3│
│(g₂,ε)  │   -1 1//2 -1//2     .     . -1//2  1//2     .     .│
│(g₃,ζ₃) │   ζ₃ 1//3     . -1//3 -1//3  1//3     .  2//3 -1//3│
│(g₃,ζ₃²)│  ζ₃² 1//3     . -1//3 -1//3  1//3     . -1//3  2//3│
└────────┴────────────────────────────────────────────────────┘

julia> charnames(uc)[uc.families[1].charNumbers]
8-element Vector{String}:
 "phi2,1"
 "phi2,2"
 "phi1,3''"
 "phi1,3'"
 "G2[1]"
 "G2[-1]"
 "G2[E3]"
 "G2[E3^2]"

The Fourier matrix is obtained by 'fourier(f)'; the field 'f.charNumbers' holds the indices of the unipotent characters which are in the family. We obtain the list of eigenvalues of Frobenius for these unipotent characters by 'Eigenvalues(f)'. The Fourier matrix and vector of eigenvalues satisfy the properties of fusion data, see below. The field 'f.charLabels' is what is displayed in the column 'labels' when displaying the family. It contains labels naturally attached to lines of the Fourier matrix. In the case of reductive groups, the family is always attached to the "drinfeld_double" of a small finite group and the '.charLabels' come from this construction.

Family(f [, charNumbers [, opt]])

This function creates a new family in two possible ways.

In the first case f is a string which denotes a family known to Chevie. Examples are "S3", "S4", "S5" which denote the family obtained as the Drinfeld double of the symmetric group on 3,4,5 elements, or "C2" which denotes the Drinfeld double of the cyclic group of order 2.

In the second case f is already a struct Family.

The other (optional) arguments add information to the family defined by the first argument. If given, the second argument becomes f.charNumbers. If given, the third argument opt is a Dict whose keys are added to the resulting family.

If opt has a key signs, this should be a list of '1' and '-1', and then the Fourier matrix is conjugated by the diagonal matrix of those signs. This is used in Spetses to adjust the matrix to the choice of signs of unipotent degrees.

julia> Family("C2")
Family(C₂,4)
Drinfeld double D(ℤ/2)
┌──────┬────────────────────────────┐
│label │eigen                       │
├──────┼────────────────────────────┤
│(1,1) │    1 1//2  1//2  1//2  1//2│
│(g₂,1)│    1 1//2  1//2 -1//2 -1//2│
│(1,ε) │    1 1//2 -1//2  1//2 -1//2│
│(g₂,ε)│   -1 1//2 -1//2 -1//2  1//2│
└──────┴────────────────────────────┘

julia> Family("C2",4:7,Dict(:signs=>[1,-1,1,-1]))
Family(C₂,4:7)
Drinfeld double D(ℤ/2)
┌──────┬──────────────────────────────────┐
│label │eigen signs                       │
├──────┼──────────────────────────────────┤
│(1,1) │    1     1  1//2 -1//2 1//2 -1//2│
│(g₂,1)│    1    -1 -1//2  1//2 1//2 -1//2│
│(1,ε) │    1     1  1//2  1//2 1//2  1//2│
│(g₂,ε)│   -1    -1 -1//2 -1//2 1//2  1//2│
└──────┴──────────────────────────────────┘

<f>*<g>: returns the tensor product of two families <f> and <g>; the Fourier matrix is the Kronecker product of the matrices for <f> and <g>, and the eigenvalues of Frobenius are the pairwise products.

conj(f::Family): is a synonym for 'galois(f,-1)'.

length(f::Family): how many characters are in the family.

FamiliesClassical(l)

l should be a list of symbols which classify the unipotent characters of a classical reductive group, like symbols(2,r) for type Bᵣ or Cᵣ, or symbols(2,r,0) for type Dᵣ. The function returns the list of families determined by these symbols.

julia> FamiliesClassical(symbols(2,3)) # for a reductive group of type B₃
6-element Vector{Family}:
 Family(112,[2])
 Family(022,[6])
 Family(3,[9])
 Family(01123,[1, 3, 8, 11])
 Family(0112233,[4])
 Family(013,[5, 7, 10, 12])

cospecial(f::Family) the index of the cospecial character in f

drinfeld_double(g;lu=false,pivotal=nothing)

Given a (usually small) finite group Γ, Lusztig has associated a family (a Fourier matrix, a list of eigenvalues of Frobenius) which describes the representation ring of the Drinfeld double of the group algebra of Γ, and for some appropriate small groups describes a family of unipotent characters. We do not explain the details of this construction, but explain how its final result building Lusztig's Fourier matrix, and a variant of it that we use in Spetses, from Γ.

The elements of the family are in bijection with the set 𝓜 (Γ) of pairs (x,φ) taken up to Γ-conjugacy, where x∈Γ and φ is an irreducible complex-valued character of C_Γ(x). To such a pair ρ=(x,φ) is associated an eigenvalue of Frobenius defined by $ω_ρ:=φ(x)/φ(1)$. Lusztig then defines a Fourier matrix S₀ whose coefficient is given, for ρ=(x,φ) and ρ'=(x', φ'), by:

$S₀_{ρ,ρ'}:=|C_Γ(x)⁻¹|∑_{ρ₁=(x₁,φ₁)}φ₁(x)φ(y₁)$

where the sum is over all pairs ρ₁∈𝓜 (Γ) which are Γ-conjugate to ρ' and such that $y₁∈ C_Γ(x)$. This coefficient also represents the scalar product $⟨ρ,ρ'⟩_{𝐆^F}$ of the corresponding unipotent characters.

A way to understand the formula for $S₀_{ρ,ρ'}$ better is to consider another basis of the complex vector space with basis 𝓜 (Γ), indexed by the pairs (x,y) taken up to Γ-conjugacy, where x and y are commuting elements of Γ. This basis is called the basis of Mellin transforms, and given by:

$(x,y)=∑_{φ∈ Irr(C_Γ(x))}φ(y)(x,φ)$

In the basis of Mellin transforms, the linear map S₀ is given by (x,y)↦(x⁻¹,y⁻¹) and the linear transformation T which sends ρ to ω_ρρ becomes (x,y)↦(x,xy). These are particular cases of the permutation representation of GL₂(ℤ) on the basis of Mellin transforms where $\begin{pmatrix}a&b\cr c&d\end{pmatrix}$ acts by (x,y)↦(xᵃyᵇ,xᶜyᵈ).

Fourier matrices in finite reductive groups are given by the above matrix S₀. But for non-rational Spetses, we use a different matrix S which in the basis of Mellin transforms is given by (x,y)↦(y⁻¹,x). Equivalently, the formula $S_{ρ,ρ'}$ differs from the formula for $S₀_{ρ,ρ'}$ in that there is no complex conjugation of χ₁; thus the matrix S is equal to S₀ multiplied on the right by the permutation matrix which corresponds to (x,φ)↦(x,φ). The advantage of the matrix S over S₀ is that the pair S,T satisfies directly the axioms for a fusion algebra (see below); also the matrix S is symmetric, while S₀ is Hermitian.

Thus there are two variants of 'drinfeld_double`:

drinfeld_double(g;lu=false)

returns a family containing Lusztig's Fourier matrix S₀, and an extra field '.perm' containing the permutation of the indices induced by (x,φ)↦(x,φ), which allows to recover S, as well as an extra field `:lusztig', set to 'true'.

drinfeld_double(g)

returns a family with the matrix S, which does not have fields '.lusztig' or '.perm'.

The family record 'f' returned also has the fields:

:group: the group Γ.

:charLabels: a list of labels describing the pairs (x,φ), and thus also specifying in which order they are taken.

:fourierMat: the Fourier matrix (the matrix S or S₀ depending on the call).

:eigenvalues: the eigenvalues of Frobenius.

:xy: a list of pairs '[x,y]' which are representatives of the Γ-orbits of pairs of commuting elements.

:mellinLabels: a list of labels describing the pairs '[x,y]'.

:mellin: the base change matrix between the basis (x,φ) and the basis of Mellin transforms, so that |f.fourierMat^(f.mellin^-1)| is the permutation matrix (for (x,y)↦(y⁻¹,x) or (x,y)↦(y⁻¹,x⁻¹) depending on the call).

:special: the index of the special element, which is (x,φ)=(1,1).

julia> drinfeld_double(coxsym(3)) # needs "using GAP"
Family(drinfeld_double(coxsym(3)),8)
Drinfeld double D(coxsym(3))
┌───────┬────────────────────────────────────────────────────┐
│label  │eigen                                               │
├───────┼────────────────────────────────────────────────────┤
│(1,1)  │    1  1//6  1//3 1//6 -1//2 -1//2  1//3  1//3  1//3│
│(1,X.2)│    1  1//3  2//3 1//3     .     . -1//3 -1//3 -1//3│
│(1,X.3)│    1  1//6  1//3 1//6  1//2  1//2  1//3  1//3  1//3│
│(21,1) │    1 -1//2     . 1//2  1//2 -1//2     .     .     .│
│(21,-1)│   -1 -1//2     . 1//2 -1//2  1//2     .     .     .│
│(3,1)  │    1  1//3 -1//3 1//3     .     .  2//3 -1//3 -1//3│
│(3,ζ₃) │   ζ₃  1//3 -1//3 1//3     .     . -1//3 -1//3  2//3│
│(3,ζ₃²)│  ζ₃²  1//3 -1//3 1//3     .     . -1//3  2//3 -1//3│
└───────┴────────────────────────────────────────────────────┘

julia> drinfeld_double(coxsym(3);lu=true)
Family(Ldrinfeld_double(coxsym(3)),8)
Lusztig′sDrinfeld double D(coxsym(3))
┌───────┬────────────────────────────────────────────────────┐
│label  │eigen                                               │
├───────┼────────────────────────────────────────────────────┤
│(1,1)  │    1  1//6  1//3 1//6 -1//2 -1//2  1//3  1//3  1//3│
│(1,X.2)│    1  1//3  2//3 1//3     .     . -1//3 -1//3 -1//3│
│(1,X.3)│    1  1//6  1//3 1//6  1//2  1//2  1//3  1//3  1//3│
│(21,1) │    1 -1//2     . 1//2  1//2 -1//2     .     .     .│
│(21,-1)│   -1 -1//2     . 1//2 -1//2  1//2     .     .     .│
│(3,1)  │    1  1//3 -1//3 1//3     .     .  2//3 -1//3 -1//3│
│(3,ζ₃) │   ζ₃  1//3 -1//3 1//3     .     . -1//3  2//3 -1//3│
│(3,ζ₃²)│  ζ₃²  1//3 -1//3 1//3     .     . -1//3 -1//3  2//3│
└───────┴────────────────────────────────────────────────────┘

family_imprimitive(S)

S should be a symbol for a unipotent characters of an imprimitive complex reflection group 'G(e,1,n)' or 'G(e,e,n)'. The function returns the family containing S.

julia> family_imprimitive([[0,1],[1],[0]])
Family(0011,3)
imprimitive family
┌─────┬──────────────────────────────┐
│label│eigen      1        2        3│
├─────┼──────────────────────────────┤
│1    │  ζ₃²  √-3/3   -√-3/3    √-3/3│
│2    │    1 -√-3/3 ζ₃²√-3/3 -ζ₃√-3/3│
│3    │    1  √-3/3 -ζ₃√-3/3 ζ₃²√-3/3│
└─────┴──────────────────────────────┘

fourier(f::Family: returns the Fourier matrix for the family f.

fusion_algebra(f::Family) or fusion_algebra(S,special=1)

All the Fourier matrices S in Chevie are unitary, that is S⁻¹=conj(S), and have a special line s (the line of index s=special(f) for a family f) such that no entry Sₛ,ᵢ is equal to 0. Further, they have the property that the sums Cᵢ,ⱼ,ₖ=sumₗ Sᵢ,ₗ Sⱼ,ₗ conj(Sₖ,ₗ)/Sₛ,ₗ take integral values. Finally, S has the property that complex conjugation does a permutation with signs σ of the lines of S.

It follows that we can define a ℤ-algebra A as follows: it has a basis bᵢ indexed by the lines of S, and has a multiplication defined by the fact that the coefficient of bᵢbⱼ on bₖ is equal to Cᵢ,ⱼ,ₖ. This algebra can be specified by giving a family f or just its Fourier matrix and the number of its special line.

A is commutative, and has as unit the element bₛ; the basis σ(bᵢ)isdual to bᵢ for the linear form (bᵢ,bⱼ)=Cᵢ,ⱼ,σ₍ₛ₎`.

julia> W=complex_reflection_group(4)
G₄

julia> uc=UnipotentCharacters(W);f=uc.families[4];

julia> A=fusion_algebra(fourier(f),1)
Fusion Algebra dim.5

julia> b=basis(A)
5-element Vector{AlgebraElt{Chevie.Families.FusionAlgebra, Int64}}:
 B₁
 B₂
 B₃
 B₄
 B₅

julia> b*permutedims(b)
5×5 Matrix{AlgebraElt{Chevie.Families.FusionAlgebra, Int64}}:
 B₁  B₂      B₃      B₄        B₅
 B₂  -B₄+B₅  B₁+B₄   B₂-B₃     B₃
 B₃  B₁+B₄   -B₄+B₅  -B₂+B₃    B₂
 B₄  B₂-B₃   -B₂+B₃  B₁+B₄-B₅  -B₄
 B₅  B₃      B₂      -B₄       B₁

julia> CharTable(A)
CharTable(Fusion Algebra dim.5)
┌─┬─────────────────┐
│ │1    2    3  4  5│
├─┼─────────────────┤
│1│1  √-3 -√-3  2 -1│
│2│1    1    1  .  1│
│3│1   -1   -1  .  1│
│4│1    .    . -1 -1│
│5│1 -√-3  √-3  2 -1│
└─┴─────────────────┘

ndrinfeld_double(g)

This function returns the number of elements that the family associated to the Drinfeld double of the group g would have, without computing it. The evident advantage is the speed.

julia> Families.ndrinfeld_double(complex_reflection_group(5))
378

special(f::Family) the index of the special character in f

galois(f::Family,p::Int)

x->galois(x,p) is applied to the Fourier matrix and eigenvalues of Frobenius of the family.

julia> f=UnipotentCharacters(complex_reflection_group(3,1,1)).families[2]
Family(0011,[4, 3, 2])
imprimitive family
┌─────┬──────────────────────────────┐
│label│eigen      1        2        3│
├─────┼──────────────────────────────┤
│1    │  ζ₃²  √-3/3    √-3/3   -√-3/3│
│2    │    1  √-3/3 ζ₃²√-3/3 -ζ₃√-3/3│
│3    │    1 -√-3/3 -ζ₃√-3/3 ζ₃²√-3/3│
└─────┴──────────────────────────────┘

julia> galois(f,-1)
Family(conj(0011),[4, 3, 2])
conj(imprimitive family)
┌─────┬──────────────────────────────┐
│label│eigen      1        2        3│
├─────┼──────────────────────────────┤
│1    │   ζ₃ -√-3/3   -√-3/3    √-3/3│
│2    │    1 -√-3/3 -ζ₃√-3/3 ζ₃²√-3/3│
│3    │    1  √-3/3 ζ₃²√-3/3 -ζ₃√-3/3│
└─────┴──────────────────────────────┘

invpermute(f::Family, p::Perm)

returns a copy of f with the Fourier matrix, eigenvalues of Frobenius, :charLabels… invpermuted by p.

julia> f=UnipotentCharacters(complex_reflection_group(3,1,1)).families[2]
Family(0011,[4, 3, 2])
imprimitive family
┌─────┬──────────────────────────────┐
│label│eigen      1        2        3│
├─────┼──────────────────────────────┤
│1    │  ζ₃²  √-3/3    √-3/3   -√-3/3│
│2    │    1  √-3/3 ζ₃²√-3/3 -ζ₃√-3/3│
│3    │    1 -√-3/3 -ζ₃√-3/3 ζ₃²√-3/3│
└─────┴──────────────────────────────┘

julia> invpermute(f,Perm(1,2,3))
Family(0011,[2, 4, 3])
Permuted((1,2,3),imprimitive family)
┌─────┬──────────────────────────────┐
│label│eigen        3      1        2│
├─────┼──────────────────────────────┤
│3    │    1 ζ₃²√-3/3 -√-3/3 -ζ₃√-3/3│
│1    │  ζ₃²   -√-3/3  √-3/3    √-3/3│
│2    │    1 -ζ₃√-3/3  √-3/3 ζ₃²√-3/3│
└─────┴──────────────────────────────┘

FFE{p}(z::Cyc) where z is a p-integral cyclotomic number (that is, z times some number prime to p is a cyclotomic integer), returns the reduction of z mod. p, an element of some extension 𝔽_{pʳ} of the prime field 𝔽ₚ.

julia> FFE{3}(E(7))
Z₇₂₉¹⁰⁴

abelian_gens(A)

A should be an abelian group or the list of its generators. Such a group has a unique decomposition up to isomorphism as a product of cyclic groups C(n₁)×…×C(nₖ) where C(nᵢ) is a cyclic group of order nᵢ and nᵢ divides nᵢ₊₁. The function returns a list of generators for each of the C(nᵢ).

julia> abelian_gens([Perm(1,2),Perm(3,4,5),Perm(6,7)])
2-element Vector{Perm{Int16}}:
 (6,7)
 (1,2)(3,5,4)(6,7)

abelian_invariants(G::Group )

G should be an abelian group. Such a group has a unique decomposition up to isomorphism as a product of cyclic groups C(n₁)×…×C(nₖ) where C(nᵢ) is a cyclic group of order nᵢ and nᵢ divides nᵢ₊₁. The function returns the list n₁,…,nₖ.

julia> abelian_invariants(Group(Perm(1,2),Perm(3,4,5),Perm(6,7)))
2-element Vector{Int64}:
 2
 6

valuation(c::Union{Integer,Rational{<:Integer},p::Integer) p-adic valuation of c (largest power of p which divides c; for a Rational, valuation of the numerator minus that of the denominator).

julia> valuation.(24,(2,3,5))
(3, 1, 0)

Factoring polynomials over finite fields

see factor.

factors_same_degree(f::Pol{FFE{p}},d,F::GF)where p

find the irreducible factors of f assumed to be a square free product of monic irreducible factors of degree d over a finite field F of characteristic p.

factors_squarefree(f::Pol{FFE{p}},F::GF)where p

find the irreducible factors of f assumed to be a square free monic polynomial with nonzero constant term over a finite field F of characteristic p.

factor(f::Pol{FFE{p}}[, F])

Given f a polynomial over a finite field of characteristic p, factor f, by default over the field of its coefficients, or if specified over the field F. The result is a Primes.Factorization{Pol{FFE{p}}}.

julia> @Pol q
Pol{Int64}: q

julia> f=q^3*(q^4-1)^2*Z(3)^0
Pol{FFE{3}}: q¹¹+q⁷+q³

julia> factor(f)
(q²+1)² * (q+1)² * (q-1)² * q³

julia> factor(f,GF(9))
(q+1)² * (q-1)² * (q+Z₉²)² * (q+Z₉⁶)² * q³

This module implements Hecke algebras associated to finite complex reflection groups and arbitrary Coxeter groups (these algebras are called Iwahori-Hecke algebras in this last case), and also implements the character tables, Schur elements and representations of Hecke algebras for finite groups. For Iwahori-Hecke algebras and G(d,1,1) this module also implements the standard T basis; see the module KLfor Kazhdan-Lusztig bases.

Let (W,S) be a Coxeter system and let mₛₜ be the order of st for s,t∈ S. Let R be a commutative ring with 1 and for s∈ S let uₛ₀,uₛ₁∈ R be elements which depend only on the conjugacy class of s in W (this is the same as requiring that uₛᵢ=uₜᵢ whenever mₛₜ is odd). The Iwahori-Hecke algebra of W over R with parameters uₛᵢ is a deformation of the group algebra of W over R defined as follows: it is the unitary associative R-algebra generated by elements Tₛ, s∈ S subject to the relations:

$(Tₛ-uₛ₀)(Tₛ-uₛ₁)=0$ for all s∈ S (the quadratic relations)

$TₛTₜTₛ…= TₜTₛTₜ…$ with mₛₜ factors on each side (the braid relations)

If uₛ₀=1 and uₛ₁=-1 for all s then the quadratic relations become Tₛ²=1 and the deformation of the group algebra is trivial.

Since the generators Tₛ satisfy the braid relations, H is in fact a quotient of the group algebra of the braid group associated with W. The braid relations also imply that for any reduced expression s_1⋯ s_m of w ∈ W the product Tₛ_1⋯ Tₛ_m has the same value, that we denote T_w. We have T_1=1; if one of the uₛᵢ is invertible, the {T_w}_{w∈ W} form an R-basis of the Iwahori-Hecke algebra which specializes to the canonical basis of the group algebra R[W] for uₛ₀↦1 and uₛ₁↦-1.

When one of the uₛᵢ is invertible, the structure constants (the decomposion of a product T_vT_w) in the T_w basis are obtained as follows. Choose a reduced expression for v, say v=s_1 ⋯ s_k and apply inductively the formula:

$T_sT_w=T_{sw}$ if l(sw)=l(w)+1

$T_sT_w=-uₛ₀uₛ₁T_{sw}+(uₛ₀+uₛ₁)T_w$ if l(sw)=l(w)-1.

If one of uₛ₀ or uₛ₁ is invertible in R, for example uₛ₁, then by changing the generators to T′ₛ=-Tₛ/uₛ₁, and setting qₛ=-uₛ₀/uₛ₁, the braid relations do no change (since when mₛₜ is odd we have uₛᵢ=uₜᵢ) but the quadratic relations become (T′ₛ-qₛ)(T′ₛ+1)=0. This normalisation is the most common form considered in the literature. Another common form in the context of Kazhdan-Lusztig theory, is uₛ₀=√qₛ and uₛ₁=-√qₛ⁻¹. The form provided, with two parameters per generator, is often useful, for instance when constructing the Jones polynomial. If for all s we have uₛ₀=q, uₛ₁=-1 then we call the corresponding algebra the "one-parameter" or "Spetsial" Iwahori-Hecke algebra associated with W.

For some Iwahori-Hecke algebras the character table, and in general Kazhdan-Lusztig bases, require a square root of -uₛ₀uₛ₁. These square roots can be specified with the keyword rootpara when constructing the algebra; after this the function rootpara(H) will return the chosen roots. If not specified, we try to extract roots automatically when needed; rootpara(H) informs on the choices made. Note that some mathematical results require an explicit choice of one of the two possible roots which cannot be automatically made thus require a keyword initialisation.

There is a universal choice for R and uₛᵢ: Let uₛᵢ:s∈ S,i∈[0,1] be indeterminates such that uₛᵢ=uₜᵢ whenever mₛₜ is odd, and let A=ℤ[uₛᵢ] be the corresponding polynomial ring. Then the Hecke algebra H of W over A with parameters uₛᵢ is called the generic Iwahori-Hecke algebra of W. Any Hecke algebra H₁ with parameters vₛᵢ can be obtained by specialization from H, since there is a unique ring homomorphism f:A → R such that f(uₛᵢ)=vₛᵢ for all i. Then via f we can identify H₁ to $R⊗ _A H$.

Certain invariants of the irreducible characters of the one-parameter Hecke algebra play a special role in the representation theory of the underlying finite Coxeter groups, namely the a- and A-invariants. For basic properties of Iwahori-Hecke algebras and their relevance to the representation theory of finite groups of Lie type, see for example Curtis and Reiner 1987 Sections~67 and 68.

In the following example, we compute the multiplication table for the 0-Iwahori–Hecke algebra associated with the Coxeter group of type A_2.

julia> W=coxgroup(:A,2)
A₂

julia> H=hecke(W,0)            # One-parameter algebra with `q=0`
hecke(A₂,0)

julia> T=Tbasis(H);            # Create the `T` basis

julia> b=T.(elements(W))       # the basis
6-element Vector{HeckeTElt{HeckeAlgebra{Int64, Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}, Int64, Perm{Int16}}}:
 T.
 T₁
 T₂
 T₁₂
 T₂₁
 T₁₂₁

julia> b*permutedims(b)       # multiplication table
6×6 Matrix{HeckeTElt{HeckeAlgebra{Int64, Perm{Int16}, FiniteCoxeterGroup{Perm{Int16},Int64}}, Int64, Perm{Int16}}}:
 T.    T₁     T₂     T₁₂    T₂₁    T₁₂₁
 T₁    -T₁    T₁₂    -T₁₂   T₁₂₁   -T₁₂₁
 T₂    T₂₁    -T₂    T₁₂₁   -T₂₁   -T₁₂₁
 T₁₂   T₁₂₁   -T₁₂   -T₁₂₁  -T₁₂₁  T₁₂₁
 T₂₁   -T₂₁   T₁₂₁   -T₁₂₁  -T₁₂₁  T₁₂₁
 T₁₂₁  -T₁₂₁  -T₁₂₁  T₁₂₁   T₁₂₁   -T₁₂₁

Thus, we work with algebras with arbitrary parameters. We will see that this also works on the level of characters and representations.

For general complex reflection groups, the picture is similar. The Hecke algebras are deformations of the group algebras, generalizing those for real reflection groups.

The definition is as a quotient of the algebra of the braid group. We assume now that W is a finite reflection group in the complex vector space V. The braid group associated is the fundamental group Π₁ of the space  $(V-\bigcup_{H\in\mathcal H} H)/W$, where $\mathcal H$ is the set of reflecting hyperplanes of W. This group is generated by braid reflections, elements which by the natural map from the braid group to the reflection group project to distinguished reflections. The braid reflections which project to a given W-orbit of reflections are conjugate. Let 𝐬 be a representative of such a conjugacy class of braid reflections, let e be the order of the image of 𝐬 in W, and let $u_{𝐬,0},…,u_{𝐬,e-1}$ be indeterminates. The generic Hecke algebra of W is the $ℤ[u_{𝐬,i}^{± 1}]_{𝐬,i}$-algebra quotient of the braid group algebra by the relations $(𝐬-u_{𝐬,0})…(𝐬-u_{𝐬,e-1})=0$, and an arbitrary Hecke algebra for W is an algebra obtained from this generic algebra by specializing some of the parameters.

The generic Hecke algebras are explicitely described by a presentation of the braid group. The braid group can be presented by homogeneous relations in the braid reflections, called braid relations, described in Broué-Malle-Rouquier 1998 and Bessis-Michel 2003 (some of which were obtained using the VKCURVE GAP3-package, also ported to Julia). Furthermore, these presentations are such that the reflection group is presented by the same relations, plus relations describing the order of the generating reflections, called the order relations. Thus the Hecke algebra has a presentation similar to that of W, with the same braid relations but the order relations replaced by a deformed version.

If S⊂ W is the set of distinguished reflections of W which lift to generating braid reflections in the braid group, for each conjugacy class of an s of order e we take indeterminates uₛ₀,…,uₛₑ₋₁. Then the generic Hecke algebra is the $ℤ[uₛᵢ^{±1}]ₛᵢ$-algebra H with generators T_s for each s∈ S presented by the braid relations and the deformed order relations $(T_s-u_{s,0})…(T_s-u_{s,e-1})=0$.

Ariki, Koike and Malle have computed the character table of some of these algebras, including those for all 2-dimensional reflection groups, see Broué-Malle 1993 and Malle 1996; our data has models of all representation and character tables for real reflection groups; it contains the same for imprimitive groups and for primitive groups of dimension 2 and 3 (these last representations have been computed in Malle-Michel 2010) and contains also models and character tables computed by Michel for G₂₉ and G₃₃; it contains also partial lists of representations and partial character tables for the remaining groups G₃₁,G₃₂ and G₃₄, computed by Malle and Michel for G₃₂ and by Michel for the other two algebras.

The quotient of the Hecke algebra obtained by the specialisation $u_{𝐬,i}↦ ζₑⁱ$ is isomorphic to the group algebra of W. It was conjectured for 20 years that over a splitting ring the Hecke algebra is itself isomorphic to the group algebra of W over the same ring. This was called the freeness conjecture since the main problem is to show that the Hecke algebra is free of dimension |W|. This has finally been proved in 2019 thanks to the work of many people including Marin, Pfeiffer, Chavli and Tsuchioka for exceptional groups. Along the way it has been proven that there exists a set {b_w}_{w∈ W} of elements of the Braid group such that b_1=1 and b_w maps to w by the natural quotient map, such that their images T_w form a basis of the Hecke algebra.

It is conjectured that such a basis T_w can be chosen such that additionnaly the linear form t defined by t(T_w)=0 if w≠ 1 and t(1)=1 is a symmetrizing form for the symmetric algebra H. This is well known for all real reflection groups and has been proved in Malle-Mathas 1998 for imprimitive reflection groups and in Malle-Michel 2010 for some primitive groups of dimension 2 and 3. Chlouveraki and Chavli have handled some other 2-dimensional cases. For each irreducible character φ of H we define the Schur element Sᵩ associated to φ by the condition that for any element T of H we have t(T)=∑ᵩ φ(T)/Sᵩ. It can be shown that the Schur elements are Laurent polynomials, and they do not depend on the choice of a basis having the above property. Malle has computed these Schur elements, assuming the above conjecture; they are in the Chevie data.

See the function hecke for various ways of specifying the parameters of a Hecke algebra. Look also at the docstrings of central_monomials, char_values, class_polynomials, schur_elements, isrepresentation, factorized_schur_elements, and at the methods for Hecke algebras of CharTable, representations, reflrep.

Taking apart Hecke elements is done with the functions getindex, setindex!, keys, values, iterate.

julia> H=hecke(W,Pol(:q))
hecke(A₂,q)

julia> T=Tbasis(H);

julia> h=T(1,2)^2
qT₂₁+(q-1)T₁₂₁

julia> length(h) # h has 2 terms
2

julia> h[W(2,1)] # coefficient of W(2,1)
Pol{Int64}: q

julia> collect(h) # pairs perm=>coeff
2-element Vector{Any}:
  (1,2,6)(3,4,5) => q
 (1,5)(2,4)(3,6) => q-1

julia> collect(values(h)) # the coefficients
2-element Vector{Pol{Int64}}:
 q
 q-1

julia> collect(keys(h)) # the corresponding Perms
2-element Vector{Perm{Int16}}:
 (1,2,6)(3,4,5)
 (1,5)(2,4)(3,6)

julia> h[W(2,1)]=Pol(3)
Pol{Int64}: 3

julia> h
3T₂₁+(q-1)T₁₂₁

finally, benchmarks on julia 1.8

julia> function test_w0(n)
         W=coxgroup(:A,n)
         Tbasis(hecke(W,Pol(:q)))(longest(W))^2
       end
test_w0 (generic function with 1 method)

julia> @btime test_w0(7);
   97.210 ms (1776476 allocations: 127.52 MiB)

in GAP3 the analogous function takes 920ms

test_w0:=function(n)local W,T,H;
  W:=CoxeterGroup("A",n);H:=Hecke(W,X(Rationals));T:=Basis(H,"T");
  return T(LongestCoxeterWord(W))^2;
end;

CharTable(H::HeckeAlgebra or HeckeCoset)

returns the CharTable of the Hecke algebra H. For the primitive groups G₃₁, G₃₂, G₃₄ there are Unknown() entries corresponding to missing representations (see representation). The columns of the CharTable are labelled by classnames(H.W) and contain the character values for the corresponding element given by classreps(H.W).

julia> H=hecke(crg(4),Pol())
hecke(G₄,q)

julia> CharTable(H)
CharTable(hecke(G₄,q))
┌────┬──────────────────────────────────────┐
│    │.    z 212   12    z12     1        1z│
├────┼──────────────────────────────────────┤
│φ₁‚₀│1   q⁶  q³   q²     q⁸     q        q⁷│
│φ₁‚₄│1    1   1  ζ₃²    ζ₃²    ζ₃        ζ₃│
│φ₁‚₈│1    1   1   ζ₃     ζ₃   ζ₃²       ζ₃²│
│φ₂‚₅│2   -2   .    1     -1    -1         1│
│φ₂‚₃│2 -2q³   . ζ₃²q -ζ₃²q⁴ q+ζ₃² -q⁴-ζ₃²q³│
│φ₂‚₁│2 -2q³   .  ζ₃q  -ζ₃q⁴  q+ζ₃  -q⁴-ζ₃q³│
│φ₃‚₂│3  3q²  -q    .      .   q-1     q³-q²│
└────┴──────────────────────────────────────┘

A FactSchur representing a Schur element of the form M∏ᵩφ(Mᵩ) (see factorized_schur_element) is a struct with a field factor which holds the monomial M, and a field vcyc which holds a list of NamedTuples describing each factor Mᵩ in the product. An element of vcyc representing a term φ(Mᵩ) is itself a NamedTuple with fields monomial holding Mᵩ (as an Mvp with a single term), and a field pol holding a CycPol (see CycPol) representing φ.

A few operations are implemented for FactSchur, like *, lcm. They can be evaluated partially or completely keeping as much as possible the factored form.

julia> @Mvp x,y; W=crg(4); H=hecke(W,[[1,x,y]])
hecke(G₄,Vector{Mvp{Int64, Int64}}[[1, x, y]])

julia> p=factorized_schur_element(H,[[2,5]])
-x⁻¹y(xy+1)(x-1)Φ₆(xy⁻¹)(y-1)

julia> q=p(;x=E(3)) # partial evaluation
ζ₃²√-3y⁻¹Φ₁Φ₂Φ′₆²(y)

julia> q(;y=2//1)
-9√-3/2

In contrast, the next operation expands p to an Mvp:

julia> HeckeAlgebras.expand(p)
Mvp{Cyc{Rational{Int64}},Rational{Int64}}: -x³y+x³+x²y²-2x²+x²y⁻¹-xy³+2xy-xy⁻¹+y³-2y²+1+x⁻¹y²-x⁻¹y

HeckeCosets are Hϕ where H is an Iwahori-Hecke algebra of some Coxeter group W on which the automorphism ϕ of some Spets Wϕ acts by ϕ(T_w)=T_{ϕ(w)}. For Weyl groups, this corresponds to the action of the Frobenius automorphism on the commuting algebra of the induced of the trivial representation from the rational points of some F-stable Borel subgroup to 𝐆 ^F.

julia> WF=rootdatum(:u,3)
u₃

julia> HF=hecke(WF,Pol(:v)^2;rootpara=Pol())
hecke(u₃,v²,rootpara=v)

julia> CharTable(HF)
CharTable(hecke(u₃,v²,rootpara=v))
┌───┬──────────┐
│   │ 111 21  3│
├───┼──────────┤
│111│  -1  1 -1│
│21 │-2v³  .  v│
│3  │  v⁶  1 v²│
└───┴──────────┘

Thanks to the work of Xuhua He and Sian Nie, 'class_polynomials' also make sense for these cosets. This is used to compute such character tables.

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]

representation(H::HeckeAlgebra or HeckeCoset,i)

returns, for the i-th irreducible representation of the Hecke algebra or Hecke coset H, a list of matrices images of the generators of H in a model of the representation (for Hecke cosets, the result is a NamedTuple with fields gens, a representation of hecke(H), and F, the matrix for the automorphism of H in the representation).

This function is based on the classification, and is not yet fully implemented for the Hecke algebras of the groups G₃₁, G₃₂ and G₃₄: we have 50 representations out of 59 for type G₃₁, 30 representations out of 102 for type G₃₂ and 38 representations out of 169 for type G₃₄; nothing is returned for a missing representation.

julia> W=crg(24)
G₂₄

julia> H=hecke(W,Pol(:q))
hecke(G₂₄,q)

julia> representation(H,3)
3-element Vector{Matrix{Pol{Cyc{Int64}}}}:
 [q 0 0; -q -1 0; -q 0 -1]
 [-1 0 -1; 0 -1 ((1-√-7)/2)q; 0 0 q]
 [-1 -1 0; 0 q 0; 0 (1+√-7)/2 -1]

The models implemented for imprimitive types G(de,e,n) for n>2 and de>1 (this includes Coxeter type Dₙ), excepted for G(2,2,4), G(3,3,3), G(3,3,4), G(3,3,5) and G(4,4,3), involve rational fractions.

julia> H=hecke(coxgroup(:D,5),Pol())
hecke(D₅,q)

julia> representation(H,7)
5-element Vector{Matrix{Frac{Pol{Int64}}}}:
 [q 0 0 0; 0 -1 0 0; 0 0 -1 0; 0 0 0 -1]
 [q 0 0 0; 0 -1 0 0; 0 0 -1 0; 0 0 0 -1]
 [1/(-q-1) q/(q+1) 0 0; (q²+q+1)/(q+1) q²/(q+1) 0 0; 0 0 -1 0; 0 0 0 -1]
 [-1 0 0 0; 0 1/(-q²-q-1) (-q²-q)/(-q²-q-1) 0; 0 (q³+q²+q+1)/(q²+q+1) q³/(q²+q+1) 0; 0 0 0 -1]
 [-1 0 0 0; 0 -1 0 0; 0 0 1/(-q³-q²-q-1) (-q³-q²-q)/(-q³-q²-q-1); 0 0 (q⁴+q³+q²+q+1)/(q³+q²+q+1) q⁴/(q³+q²+q+1)]

representations(H)

returns the list of representations of the Hecke algebra or Hecke coset H (see representation).

julia> WF=rootdatum("2B2")
²B₂

julia> H=hecke(WF,Pol(:x)^2;rootpara=Pol())
hecke(²B₂,x²,rootpara=x)

julia> representations(H)
3-element Vector{NamedTuple{(:gens, :F)}}:
 (gens = Matrix{Pol{Int64}}[[x²;;], [x²;;]], F = [1;;])
 (gens = [[-1;;], [-1;;]], F = [1;;])
 (gens = Matrix{Pol{Cyc{Int64}}}[[-1 0; √2x x²], [x² √2x; 0 -1]], F = [0 -1; -1 0])

α(a::HeckeTElt)

the anti-involution on the Hecke algebra defined by $T_w↦ T_{inv(w)}$.

Tbasis(H::HeckeAlgebra) The T basis of H. It is defined currently for Iwahori-Hecke algebras and for Hecke algebras of cyclic complex reflection groups G(d,1,1). It returns a function, say T, which can take an argument of the following forms

• T(i::Integer): the generator T_s where s=H.W(i).
• T(i₁,…,iᵣ): the product T(i₁)…T(iᵣ)
• T([i₁,…,iᵣ]): same as T(i₁,…,iᵣ)
• T(w) where w∈ H.W: returns T_w

julia> H=hecke(coxgroup(:A,2),Pol(:q))
hecke(A₂,q)

julia> T=Tbasis(H);T(longest(H.W))^2
q³T.+(q³-2q²+q)T₂₁+(q³-q²)T₂+(q³-q²)T₁+(q³-2q²+2q-1)T₁₂₁+(q³-2q²+q)T₁₂

julia> W=crg(3,1,1)
G₃‚₁‚₁

julia> H=hecke(crg(3,1,1),Pol(:q))
hecke(G₃‚₁‚₁,q)

julia> T=Tbasis(H);T(1)^3
(q-1)T.+(q-1)T₁+qT₁₁

alt(a::HeckeTElt)

a should be an element of an Iwahori-Hecke algebra H. the involution on H defined by x↦ bar(x) on coefficients and Tₛ↦ uₛ,₀uₛ,₁Tₛ. Essentially it corresponds to tensoring with the sign representation.

julia> W=coxgroup(:G,2);H=hecke(W,Pol(:q))
hecke(G₂,q)

julia> T=Tbasis(H);h=T(1,2)*T(2,1)
q²T.+(q²-q)T₁+(q-1)T₁₂₁

julia> alt(h)
q⁻²T.+(q⁻²-q⁻³)T₁+(q⁻³-q⁻⁴)T₁₂₁

central_monomials(H)

Let H be an Hecke algebra for the finite reflection group W. The function returns the scalars by which the image in H of π acts on the irreducible representations of H.

When W is irreducible, π is the generator of the center of the pure braid group. In general, it is the product of such elements for each irreducible component. When W is a Coxeter group, the image of π in H is $T_{w_0}^2$.

julia> H=hecke(coxgroup(:H,3),Pol(:q))
hecke(H₃,q)

julia> central_monomials(H)
10-element Vector{Pol{Cyc{Int64}}}:
 1
 q³⁰
 q¹²
 q¹⁸
 q¹⁰
 q¹⁰
 q²⁰
 q²⁰
 q¹⁵
 q¹⁵

char_values(h::HeckeTElt)

h is an element of an Iwahori-Hecke algebra H. The function returns the values of the irreducible characters of H on h (the method used is to convert to the T basis, and then use class_polynomials).

julia> W=coxgroup(:B,2)
B₂

julia> H=hecke(W,q^2;rootpara=q)
hecke(B₂,q²,rootpara=q)

julia> char_values(Cpbasis(H)(1,2,1))
5-element Vector{Pol{Int64}}:
 -q-q⁻¹
 q+q⁻¹
 0
 q³+2q+2q⁻¹+q⁻³
 0

char_values(H::HeckeAlgebra,v::Vector{<:Integer})

For an Iwahori-Hecke algebra this computes the character values of H on the Tbasis(H)(v).

For H the Hecke algebra of a complex reflection group W this routine computes character values on a lift of the element of W defined by the word v in gens(W).

For complex reflection groups the character table of the generic Hecke algebra of W has been computed (not entirely for 3 exceptions, see representation) in the sense that, if s₁,…,sₙ are generators of the braid group lifting the Broué-Malle-Rouquier-Bessis-Michel generators of W, there is at least one element v in each conjugacy class of W and one expression in the generators for it such that the character values of the image Tᵥ in the Hecke algebra of the lift to the braid group are known. Such an expression in the generators will be called a known word (the list of known words is obtained by word.(conjugacy_classes(W)). If the word v is known, the computation is quick using the character table. If not, the function computes the trace of Tᵥ in each irreducible representation. The values returned are Unknown() for missing representations (see representation).

julia> W=crg(4)
G₄

julia> H=hecke(W,Pol(:q))
hecke(G₄,q)

julia> char_values(H,[2,1,2])
7-element Vector{Pol{Cyc{Int64}}}:
 q³
 1
 1
 0
 0
 0
 -q

class_polynomials(h::HeckeElt)

returns the class polynomials of the element h of the Iwahori-Hecke algebra or coset given by h.H with respect to the T basis for a set R of representatives of minimal length in the conjugacy classes of the Coxeter group or coset H.W. Such minimal length representatives are given by classreps(H.W). The vector p of these polynomials has the property that if X is the matrix of the values of the irreducible characters of H on T_w (for w∈ R), then the product X*p is the list of values of the irreducible characters on h.

julia> W=coxsym(4)
𝔖 ₄

julia> H=hecke(W,Pol(:q))
hecke(𝔖 ₄,q)

julia> h=Tbasis(H,longest(W))
T₁₂₁₃₂₁

julia> p=class_polynomials(h)
5-element Vector{Pol{Int64}}:
 0
 0
 q²
 q³-2q²+q
 q³-q²+q-1

The class polynomials were introduced in Geck-Pfeiffer1993.

factorized_schur_element(H,phi)

returns the factorized schur_element (see factorized_schur_elements) of the Hecke algebra H for the irreducible character of H of parameter phi (see charinfo(W).charparams)

julia> W=complex_reflection_group(4)
G₄

julia> @Mvp x,y; H=hecke(W,[[1,x,y]])
hecke(G₄,Vector{Mvp{Int64, Int64}}[[1, x, y]])

julia> factorized_schur_element(H,[[2,5]])
-x⁻¹y(xy+1)(x-1)Φ₆(xy⁻¹)(y-1)

factorized_schur_elements(H)

Let H be a Hecke algebra for the complex reflection group W, whose parameters are all (Laurent) monomials in some variables x₁,…,xₙ, and let K be the field of definition of W. Then Maria Chlouveraki has shown that the Schur elements of H take the particular form M ∏ᵩ φ(Mᵩ) where φ runs over a list of K-cyclotomic polynomials, and M and Mᵩ are (Laurent) monomials (in possibly some fractional powers) of the variables xᵢ. The function factorized_schur_elements returns a data structure (see HeckeAlgebras.FactSchur) which shows this factorization.

julia> W=complex_reflection_group(4)
G₄

julia> @Mvp x,y; H=hecke(W,[[1,x,y]])
hecke(G₄,Vector{Mvp{Int64, Int64}}[[1, x, y]])

julia> factorized_schur_elements(H)
7-element Vector{Chevie.HeckeAlgebras.FactSchur}:
 x⁻⁴y⁻⁴(xy+1)Φ₁Φ₆(x)Φ₁Φ₆(y)
 (x²y⁻¹+1)Φ₁Φ₆(x)Φ₁Φ₆(xy⁻¹)
 -x⁻⁴y⁵Φ₁Φ₆(xy⁻¹)(xy⁻²+1)Φ₁Φ₆(y)
 -x⁻¹y(xy+1)(x-1)Φ₆(xy⁻¹)(y-1)
 -x⁻⁴y(x²y⁻¹+1)(x-1)(xy⁻¹-1)Φ₆(y)
 x⁻¹y⁻¹Φ₆(x)(xy⁻¹-1)(xy⁻²+1)(y-1)
 x⁻²y(x²y⁻¹+1)(xy+1)(xy⁻²+1)

hecke(HF::HeckeCoset) returns the underlying Hecke algebra

hecke(WF::Spets, H)

hecke(WF::Spets, params)

Construct a HeckeCoset from a Coxeter coset WF and an Hecke algebra associated to Group(WF). The second form is equivalent to Hecke(WF,Hecke(Group(WF),params)). See the doc for HeckeCoset.

hecke( W [, parameter];rootpara=nothing)

Hecke algebra for the complex reflection group or Coxeter group W. If no parameter is given, 1 is assumed which gives the group algebra of W.

The following forms are accepted for parameter: if parameter is not a vector or a tuple, it is replaced by the vector fill(parameter,ngens(W)). If it is a vector with one entry, it is replaced with fill(parameter[1],ngens(W)). If parameter is a vector with more than one entry, it should have length ngens(W), each entry representing the parameters for the corresponding generator of W, and entries corresponding to the same W-orbit of generators should be identical. Finally, if parameter is a Tuple, the tuple should have as many entries as there are hyperplane orbits in W and each entry will represent the parameters for the corresponding conjugacy class of braid reflections.

An entry in parameter for a reflection of order e can be either a single scalar value or a Vector of length 'e'. If it is a Vector, it is interpreted as the list [u₀,…,u_(e-1)] of parameters for that reflection. If it is not a vector, let q be its value; it is then interpreted as specifying the list of parameters for the Spetsial algebra, which are [q,ζ_e,…,ζ_{e-1}] (thus the list [q,-1] of the one-parameter algebra for Coxeter groups).

When printing an Hecke algebra the parameter list is abbreviated using the same conventions.

Computing characters or representations of Hecke algebra needs sometimes to extract roots of the parameters. These roots are extracted automatically (when possible). For Coxeter groups it is possible to give explicit roots by giving a keyword argument rootpara: if it is a vector it should contain at the i-th position a square root of -parameter[i][1]*parameter[i][2]; if a scalar it is replaced by fill(rootpara,ngens(W)).

Example

julia> W=coxgroup(:B,2)
B₂

julia> @Pol q
Pol{Int64}: q

julia> H=hecke(W,q)
hecke(B₂,q)

julia> H.para
2-element Vector{Vector{Pol{Int64}}}:
 [q, -1]
 [q, -1]

julia> H=hecke(W,q^2,rootpara=-q)
hecke(B₂,q²,rootpara=-q)

julia> H=hecke(W,q^2)
hecke(B₂,q²)

julia> rootpara(H)
2-element Vector{Pol{Int64}}:
 q
 q

julia> H
hecke(B₂,q²,rootpara=q)

julia> H=hecke(W,[q^2,q^4],rootpara=[q,q^2])
hecke(B₂,Pol{Int64}[q², q⁴],rootpara=Pol{Int64}[q, q²])

julia> H.para,rootpara(H)
(Vector{Pol{Int64}}[[q², -1], [q⁴, -1]], Pol{Int64}[q, q²])

julia> H=hecke(W,9,rootpara=3)
hecke(B₂,9,rootpara=3)

julia> H.para,rootpara(H)
([[9, -1], [9, -1]], [3, 3])

julia> @Mvp x,y,z,t

julia> H=hecke(W,[[x,y]])
hecke(B₂,Vector{Mvp{Int64, Int64}}[[x, y]])

julia> rootpara(H);H
hecke(B₂,Vector{Mvp{Int64, Int64}}[[x, y]],rootpara=ζ₄x½y½)

julia> H=hecke(W,[[x,y],[z,t]])
hecke(B₂,Vector{Mvp{Int64, Int64}}[[x, y], [z, t]])

julia> rootpara(H);H
hecke(B₂,Vector{Mvp{Int64, Int64}}[[x, y], [z, t]],rootpara=Mvp{Cyc{Int64}, Rational{Int64}}[ζ₄x½y½, ζ₄t½z½])

julia> hecke(coxgroup(:F,4),(q,q^2)).para
4-element Vector{Vector{Pol{Int64}}}:
 [q, -1]
 [q, -1]
 [q², -1]
 [q², -1]

julia> hecke(complex_reflection_group(3,1,2),q).para # spetsial parameters
2-element Vector{Vector{Pol{Cyc{Int64}}}}:
 [q, ζ₃, ζ₃²]
 [q, -1]

isrepresentation(H::HeckeAlgebra,r)

returns true or false, according to whether a given set r of elements corresponding to the standard generators of the reflection group H.W defines a representation of the Hecke algebra H or not.

julia> H=hecke(coxgroup(:F,4))
hecke(F₄,1)

julia> isrepresentation(H,reflrep(H))
true

julia> isrepresentation(H,Tbasis(H).(1:4))
true

schur_elements(H)

returns the list of Schur elements for the Hecke algebra H

julia> H=hecke(complex_reflection_group(4),Pol(:q))
hecke(G₄,q)

julia> s=schur_elements(H)
7-element Vector{Pol{Cyc{Rational{Int64}}}}:
 q⁸+2q⁷+3q⁶+4q⁵+4q⁴+4q³+3q²+2q+1
 2√-3+(6+4√-3)q⁻¹+12q⁻²+(6-4√-3)q⁻³-2√-3q⁻⁴
 -2√-3+(6-4√-3)q⁻¹+12q⁻²+(6+4√-3)q⁻³+2√-3q⁻⁴
 2+2q⁻¹+4q⁻²+2q⁻³+2q⁻⁴
 ζ₃²√-3q³+(3-√-3)q²+3q+3+√-3-ζ₃√-3q⁻¹
 -ζ₃√-3q³+(3+√-3)q²+3q+3-√-3+ζ₃²√-3q⁻¹
 q²+2q+2+2q⁻¹+q⁻²

julia> CycPol.(s)
7-element Vector{CycPol{Cyc{Rational{Int64}}}}:
 Φ₂²Φ₃Φ₄Φ₆
 2√-3q⁻⁴Φ₂²Φ′₃Φ′₆
 -2√-3q⁻⁴Φ₂²Φ″₃Φ″₆
 2q⁻⁴Φ₃Φ₄
 ζ₃²√-3q⁻¹Φ₂²Φ′₃Φ″₆
 -ζ₃√-3q⁻¹Φ₂²Φ″₃Φ′₆
 q⁻²Φ₂²Φ₄

reflection_representation(H::HeckeAlgebra) or reflrep(H)

returns a list of matrices for the generators of H which give the reflection representation of the Iwahori-Hecke algebra H.

julia> W=coxgroup(:B,2);H=hecke(W,Pol(:q))
hecke(B₂,q)

julia> reflrep(H)
2-element Vector{Matrix{Pol{Int64}}}:
 [-1 0; -q q]
 [q -2; 0 -1]

julia> H=hecke(coxgroup(:H,3))
hecke(H₃,1)

julia> reflrep(H)
3-element Vector{Matrix{Cyc{Int64}}}:
 [-1 0 0; -1 1 0; 0 0 1]
 [1 (-3-√5)/2 0; 0 -1 0; 0 -1 1]
 [1 0 0; 0 1 -1; 0 0 -1]

This is my attempt to port the Chevie package from GAP3 to Julia. I started this project at the end of 2018 and it is still in flux so some function names or interfaces may still change. Pull requests and issues are welcome.

I have implemented the GAP functionality (infrastructure) needed to make Chevie work. I have already registered most of this infrastructure as separate packages; the following packages are loaded and re-exported so that their functionality is automatically available when you use Chevie. In other words, Chevie is a meta-package for the following packages:

• (univariate) LaurentPolynomials (and rational fractions)
• (multivariate) PuiseuxPolynomials (and rational fractions when there are no fractional exponents)
• CyclotomicNumbers(elements of cyclotomic fields)
• ModuleElts (elements of a free module over some ring)
• Combinat (combinatorics and some basic number theory)
• PermGroups (permutations, groups, permutations groups. It contains the modules Perms and Groups which could be separate packages)
• SignedPerms (signed permutations)
• MatInt (Integer matrices and lattices)
• CycPols (cyclotomic polynomials)
• GenLinearAlgebra (linear algebra on any field/ring)
• FinitePosets (finite posets)
• FiniteFields (finite fields)
• GroupPresentations (presentations of groups, and groups defined by generators and relations)
• UsingMerge (Automatically compose several packages)

Have a look at the documentation of the above packages to see how to use their features.

I have implemented some other infrastructure which currently resides in Chevie but may eventually become separate packages:

• factorizing polynomials over finite fields (module FFfac)
• factorizing polynomials over the rationals (module Fact)
• Number fields which are subfields of the Cyclotomics (module Nf)

For permutation groups I have often replaced GAP's sophisticated algorithms with naive but easy-to-write methods suitable only for small groups (sufficient for the rest of the package but perhaps not for your needs). Otherwise the infrastructure code is often competitive with GAP, despite using much less code (often 100 lines of Julia replace 1000 lines of C); and I am sure it could be optimised better than I did. Comments on code and design are welcome. For functions that are too inefficient or difficult to implement (such as character tables of arbitrary groups), Chevie uses the GAP package as an extension. This means that if you have the GAP package installed, Chevie will automatically call GAP to implement these functions.

Functions in the Chevie.jl package are often 10 times faster than the equivalent functions in GAP3/Chevie (after the maddeningly long compilation time on the first run –- Julia's TTFP).

The Chevie package currently contains about 95% of the GAP3 Chevie functionality. If you are a user of GAP3/Chevie, the gap function can help you to find the equivalent functionality in Chevie.jl to a Gap3 function: it takes a string and gives you Julia translations of functions in Gap3 that match that string.

julia> gap("words")
CharRepresentationWords  =>  traces_words_mats
CoxeterWords(W[,l])      =>  word.(Ref(W),elements(W[,l]))
GarsideWords             =>  elements

You can then access online help for the functions you have found.

The port to Julia is not complete in the sense that 80% of the code is the data library from Chevie, which was automatically ported by a transpiler so its code is "strange". When the need to maintain the GAP3 and Julia versions simultaneously subsides, I will do a proper translation of the data library, which should give an additional speed boost.

Installing

This is a registered package that can be installed/upgraded in the standard way. For Julia newbies, we will remind you what this is. To install, do this at the REPL command line:

• enter package mode with ]
• do the command

(@v1.10) pkg> add Chevie

• exit package mode with backspace and then do

julia> using Chevie

and you are set up. For first help, type "?Chevie".

To update later to the latest version, do

(@v1.10) pkg> update

Chevie.jl requires julia 1.10 or later.

InducedDecompositionMatrix(R,W,d)

returns the induced from the Levi L to the reductive group W of the generic Φ_d decomposition matrix of L.

julia> W=rootdatum(:psu,6)
psu₆

julia> L=reflection_subgroup(W,[1,2,4,5])
psu₆₍₁₂₅₄₎=(A₂A₂)₍₁₂₄₃₎Φ₁

julia> InducedDecompositionMatrix(L,W,6)
Induced Φ₆-decomposition matrix from psu₆₍₁₂₅₄₎=(A₂A₂)₍₁₂₄₃₎Φ₁ to psu₆

┌────┬────────┐
│    │ps ps A₂│
├────┼────────┤
│²A₅ │ .  .  .│
│.3  │ 1  .  .│
│3.  │ 1  .  .│
│.21 │ 1  1  .│
│1.2 │ 2  1  .│
│21. │ 1  1  .│
│2.1 │ 2  1  .│
│.111│ .  1  1│
│111.│ .  1  1│
│1.11│ 1  2  1│
│11.1│ 1  2  1│
└────┴────────┘

The matrix itself is stored in the field .scalar of the returned struct.

EvalPolRoot(pol, x, n, p) compute pol(p*x^(1/n))

The point of this routine is to avoid unnecessary root extractions during evaluation (e.g., if pol has no terms of odd degree and n=2, then no root extraction is necessary).

this was in lib/util.g but is used only here

the elementary symmetric function of degree t in the variables v

the homogeneous symmetric function of degree t in the variables v

hooksβ(S,s) the list of all hooks of area less than or equal to s in the Young diagram of the partition with βlist S.

stripsβ(S,s) returns as a list of lists of Hooks all broken border strips (union of disjoint hooks) of area less than or equal to s in the Young diagram of the partition with βlist S.

generic_decomposition_matrix(W,d)

This function obtains the Φ_d-decomposition matrix for the reductive group specified by the Coxeter group or coset W from the package GenericDecMats.

julia> W=rootdatum(:psu,5)
psu₅

julia> generic_decomposition_matrix(W,13)
!!! Φ-decomposition matrices available for ²A₄: Φ₁₀ Φ₂ Φ₄ Φ₆

julia> generic_decomposition_matrix(W,10)
Φ₁₀-decomposition matrix for psu₅
┌──────┬─────────────────────────┐
│      │ps 21 ps ps ps 2111 11111│
├──────┼─────────────────────────┤
│2.    │ 1  .  .  .  .    .     .│
│²A₂:2 │ .  1  .  .  .    .     .│
│11.   │ .  .  1  .  .    .     .│
│1.1   │ 1  .  .  1  .    .     .│
│.2    │ .  .  .  .  1    .     .│
│²A₂:11│ .  1  .  .  .    1     .│
│.11   │ .  .  .  1  .    .     1│
└──────┴─────────────────────────┘

The matrix itself is stored in the field .scalar of the returned struct.

coefficients(c::Cyc)

for a cyclotomic c of conductor n, returns a vector v of length n such that c==∑ᵢ vᵢ₊₁ ζⁱ for i∈ 0:n-1.

julia> coefficients(Cyc(E(9)))
9-element Vector{Int64}:
  0
  0
  0
  0
 -1
  0
  0
 -1
  0

root(x,n=2)

computes an n-th root of x when we know how to do it. We know how to compute n-th roots of roots of unity, and n-th or 2n-th roots of perfect n-th powers of integers or rationals.

julia> root(-1)
Cyc{Int64}: ζ₄

julia> root(E(4))
Root1: ζ₈

julia> root(27//8,6)
Cyc{Rational{Int64}}: √6/2

diagram(W) prints a diagram describing a presentation of the finite reflection group or spets W

julia> diagram(coxgroup(:E,8))
    O 2
    ￨
O—O—O—O—O—O—O E₈
1 3 4 5 6 7 8

julia> diagram(crg(33))
    3 ②       G₃₃
     /^\
② ——② ——② ——② 
1   2   4   5     423423=342342

Let V be a vector space over a subfield K of the complex numbers (in Julia the elements of K will be usually represented by Rationals or Cycs).

A complex reflection is an element s∈ GL(V) of finite order whose fixed point set is a hyperplane, the reflecting hyperplane Hₛ of s.

Most of the time we abbreviate "complex reflection" to reflection; in some literature "reflection" is reserved for s of order 2 and otherwise pseudo-reflection is used.

A reflection s has a unique eigenvalue ζₛ not equal to 1, which is a root of unity; if K is a subfield of the real numbers, ζₛ is necessarily equal to -1 and s is of order 2. An eigenvector r∈ V of s for the eigenvalue ζₛ is called a root of s and a linear form rᵛ on V of kernel Hₛ is called a coroot of s. If r and rᵛ are normalized so that rᵛ(r)=1-ζ, then s is the map on V defined by s(x)=x-rᵛ(x)r. Such a normalized root and coroot for s are unique up to scaling the root and inversely scaling the coroot.

A finite complex reflection group W is a finite group generated by complex reflections. Since whenever W contains a reflection s it contains its powers, W is always generated by reflections s such that ζₛ==E(d) where d is the order of s; we can also assume that s is not a power of another reflection with larger order d. Such a reflection is called a distinguished reflection of W; it is a canonical generator of the cyclic subgroup of W centralizing Hₛ. The generators of the complex reflection groups we construct are always distinguished reflections; the set of distinguished reflections are in bijection with the reflecting hyperplanes. In a real reflection group all reflections are distinguished.

It is much more efficient to compute with permutation groups than with matrix groups; hence we use for computing with a finite complex reflection group W a permutation representation on a W-invariant set of root and coroot vectors for reflections of W; that is, a set R of pairs (r,rᵛ)∈ V×Vᵛ invariant by W and such that every distinguished reflection in W is determined by some pair in R (see reflectionMatrix). Using a W-invariant set implies that there may be several pairs determining the same reflection, which differ by roots of unity. This generalizes the usual construction for Coxeter groups (the case K=ℝ) where to each reflection of W is associated two roots, one positive and one negative.

A complex reflection group is irreducible if the representation V is irreducible. For irreducible complex reflection groups, there are at least as many roots for a given reflection as the order of the center of W.

The following methods are always defined for finite complex reflection groups:

• gens(W): the (distinguished) reflections which generate W, given as permutations of the roots. reflrep(W) gives them as matrices.

• roots(W): the list of roots of W.

• coroots(W): the list of coroots, in the same order as the roots.

• refls(W): a list of distinguished reflections of W, as permutations. This list is of same length as the roots, and its i-th element is the distinguished reflection for the i-th root, so it will have repetitions. unique_refls(W) returns a sublist of 1:length(roots(W)) such that the distinguished reflections around the corresponding roots reach one time only each distinguished reflection of W.

The lists roots, coroots and refls starts with the "generating" ones (those corresponding to gens(W)).

• simpleroots(W): the generating roots as a matrix.

• simplecoroots(W): the generating coroots as a matrix.

• reflections(W) gives a list without repetitions of all reflections of W (not only the distinguished ones), as objects of type Reflection. These objects contain more information on each reflection.

The finite irreducible complex reflection groups have been completely classified by Shephard and Todd, see ShephardTodd1954. They consist of one infinite family G(de,e,r) depending on 3 parameters (which includes the infinite families of Weyl groups), and 34 exceptional groups which have been given by Shephard and Todd names which range from G₄ to G₃₇. These exceptional groups include the exceptional Weyl groups, e.g., coxgroup(:E,8) is the same as G₃₇.

We provide functions to build any finite reflection group, either by giving a list of roots and coroots defining the generating reflections (see PRG), or in terms of the classification (see complex_reflection_group). In the context e.g. of Weyl groups, one wants to describe the particular root system chosen in term of the traditional classification of crystallographic root systems. This is done via calls to the function coxeter_group (see the module Weyl). There is not yet a general theory on how to construct a nice set of roots for a non-real reflection group; the roots chosen here where obtained case-by-case; however, they satisfy several important properties:

• The generating reflections satisfy braid relations which present the braid group associated to W (see diagram).

• The field of definition of W is the field K generated by the traces of the elements of W acting on V. It is a theorem that W may be realized as a reflection group over K.

• The Cartan matrix rᵛ(r') where r and r' runs over the roots and coroots for the generating reflections has entries in the ring ℤₖ of integers of K, and the other roots (resp. coroots) are linear combinations with coefficients in ℤₖ of a linearly independent subset of them.

It turns out that all representations of W are defined over the field of definition K (see. Benard1976 and D.~Bessis' thesis). This has been known for a long time in the case K=ℚ, the case of Weyl groups, whose representations are all integral.

julia> W=complex_reflection_group(4)
G₄

julia> gens(W) # as permutations of the 24 roots
2-element Vector{Perm{Int16}}:
 (1,3,9)(2,4,7)(5,10,18)(6,11,16)(8,12,19)(13,15,20)(14,17,21)(22,23,24)
 (1,5,13)(2,6,10)(3,7,14)(4,8,15)(9,16,22)(11,12,17)(18,19,23)(20,21,24)

julia> length(unique(refls(W)))
4

julia> length(refls(W)) # 24=4*(number of roots of unity in ℚ (ζ₃))
24

julia> reflrep(W) # the generators as matrices
2-element Vector{Matrix{Cyc{Rational{Int64}}}}:
 [1 0; 0 ζ₃]
 [√-3/3 -ζ₃²√-3/3; (-3+√-3)/3 -ζ₃√-3/3]

For almost all irreducible complex reflection groups, the generating matrices for W we give have coefficients in the field of definition K. Further, the set of matrices for all elements of W is globally invariant under the Galois group of K/ℚ, thus the Galois action induces automorphisms of W. The exceptions are G₂₂, G₂₇ where the matrices are in a degree two extension of K (this is needed to have a globally invariant model, see MarinMichel2010) and some dihedral groups, as well as H₃ and H₄, where the matrices given (the usual Coxeter reflection representation over K) are not globally invariant (but one can get invariant ones by chevieget(:H4,:InvariantModel)).

julia> braid_relations(W) # as tuples of equal words in the generators
1-element Vector{Tuple{Vector{Int64}, Vector{Int64}}}:
 ([1, 2, 1], [2, 1, 2])

julia> diagram(W) # the same in pictures
③ ——③ G₄
1   2

julia> cartan(W)
2×2 Matrix{Cyc{Rational{Int64}}}:
 ζ₃²√-3     ζ₃²
   -ζ₃²  ζ₃²√-3

julia> simpleroots(W)
2×2 Matrix{Cyc{Rational{Int64}}}:
    0  ζ₃²√-3
 2ζ₃²     ζ₃²

julia> simplecoroots(W)
2×2 Matrix{Cyc{Rational{Int64}}}:
     0      1
 √-3/3  √-3/3

Let SV be the symmetric algebra of V. The invariants of W in SV are called the polynomial invariants of W. If n=dim V, they are generated as a polynomial ring by n homogeneous algebraically independent polynomials f₁,…,fₙ. The polynomials fᵢ are not uniquely determined but their degrees are. The fᵢ are called the basic invariants of W, and their degrees the reflection degrees of W; the function degrees(W) returns these invariants.

Let I be the ideal generated by the homogeneous invariants of positive degree in SV. Then SV/I is isomorphic to the regular representation of W as a W-module. It is thus a graded (by the degree of elements of SV) version of the regular representation of W. The polynomial which gives the graded multiplicity of a character φ of W in the graded module SV/I is called the fake degree of φ. The function fakedegrees returns these polynomials.

julia> degrees(W)
2-element Vector{Int64}:
 4
 6

julia> fakedegrees(W,Pol(:x))
7-element Vector{Pol{Int64}}:
 1
 x⁴
 x⁸
 x⁷+x⁵
 x⁵+x³
 x³+x
 x⁶+x⁴+x²

PRG(roots,coroots) complex reflection group with given roots and coroots

PermRootGroup is the type of reflection groups represented as a permutation group on a set of roots.

PermX(W::ComplexReflectionGroup,M::AbstractMatrix)

Let M be an invertible linear map of the reflection representation of W which preserves the set of roots of parent(W), and normalizes W (for the action of matrices on the right). PermX returns the corresponding permutation of the roots of parent(W); it returns nothing if M does not normalize the set of roots of parent(W).

julia> W=reflection_subgroup(rootdatum("E7sc"),1:6)
E₇₍₁₂₃₄₅₆₎=E₆Φ₁

julia> PermX(W,reflrep(W,longest(W)))==longest(W)
true

PermY(W::ComplexReflectionGroup,M::AbstractMatrix)

Let M be an invertible linear map on the dual of the reflection representation of W which preserves the set of coroots of parent(W), and normalizes W (for the action of matrices on the right). PermY returns the corresponding permutation of the coroots of parent(W); it returns nothing if M does not normalize the set of coroots of parent(W).

julia> W=reflection_subgroup(rootdatum("E7sc"),1:6)
E₇₍₁₂₃₄₅₆₎=E₆Φ₁

julia> PermY(W,YMatrix(W,longest(W)))==longest(W)
true

YMatrix(W,w)

Let W be a finite reflection group on the space V and let w be an element of W. The function YMatrix returns the matrix of w acting on the dual of V. This is the linear transformation of this space which acts trivially on the orthogonal of the roots and has same effect as w on the simple coroots. The function makes sense more generally for an element of the normalizer of W in the whole permutation group of the coroots.

julia> W=reflection_subgroup(rootdatum("E7sc"),1:6)
E₇₍₁₂₃₄₅₆₎=E₆Φ₁

julia> YMatrix(W,longest(W))
7×7 transpose(::Matrix{Int64}) with eltype Int64:
  0   0   0   0   0  -1  0
  0  -1   0   0   0   0  0
  0   0   0   0  -1   0  0
  0   0   0  -1   0   0  0
  0   0  -1   0   0   0  0
 -1   0   0   0   0   0  0
  2   2   3   4   3   2  1

action(W::PermRootGroup,i::Integer,p::Perm)

The elements of a PermRootGroup permute the roots of parent(W), that is are permutations on 1:nref(parent(W)). The function action translates this action of p∈ W to 1:nref(W). For a reflection subgroup we have action(W,i,p)==restriction(W,inclusion(W,i)^p) and for a parent group action(W,i,p)==i^p. The first formula is always valid since for a parent group restriction(W)==inclusion(W)==1:nref(W).

asreflection(s::Matrix [,r::AbstractVector])

s should be is a square matrix, and if given r should be a vector of length size(s,1). The function determines if s is the matrix of a complex reflection (resp. if r is given if it is the matrix of a reflection of root r; the point of giving r is to specify exactly the desired root and coroot, which otherwise are determined only up to a scalar and its inverse). The function returns nothing if s if is not a reflection (resp. not a reflection with root r), and otherwise returns a named tuple with four fields:

.root: the root of the reflection s (equal to r if given)

.coroot: the coroot of s

.eigenvalue: the non-trivial eigenvalue of s

.isunitary: a boolean which is true if and only if s is unitary with respect to the usual scalar product (then s is determined by the root and the eigenvalue as reflectionMatrix(.root,.eigenvalue))

julia> asreflection([-1 0 0;1 1 0;0 0 1])
(root = [2, 0, 0], coroot = Rational{Int64}[1, -1//2, 0], eig = -1, isunitary = false)

julia> asreflection([-1 0 0;1 1 0;0 0 1],[1,0,0])
(root = [1, 0, 0], coroot = Rational{Int64}[2, -1, 0], eig = -1, isunitary = false)

bipartite_decomposition(W)

Returns a bipartite decomposition [L,R] of the indices of the generators of the reflection group W, such that reflection_subgroup(W,L) and reflection_subgroup(W,R) are abelian subgroups, and W=reflection_subgroup(W, vcat(L,R)). Gives an error if no such decomposition is possible.

julia> bipartite_decomposition(coxgroup(:E,8))
([1, 4, 6, 8], [3, 2, 5, 7])

cartan(W::PermRootGroup,i,j) the cartan coefficient cᵢ(rⱼ), the value of the linear form given by the i-th coroot cᵢ on the j-th root rᵢ of W

cartan(W::PermRootGroup) Cartan matrix of W.

Let s₁,…,sₙ be reflections with associated roots rᵢ and coroots cᵢ. The matrix C with entries Cᵢ,ⱼ=cᵢ(rⱼ) is called a Cartan matrix of s₁,…,sₙ. Since a reflection determines up to scalar a root and a coroot, C is uniquely determined by s₁,…,sₙ up to conjugation by a diagonal matrix.

If s₁,…,sₙ generate a reflection group W, then C up to conjugation by a diagonal matrix is an invariant of the reflection representation of W. If invertible, the matrix C determines this representation since then the rᵢ form a basis in which the matrix for sᵢ differs from the identity only on the i-th row, where the corresponding row of C has been subtracted.

In general cartan(W)==simplecoroots(W)*permutedims(simpleroots(W)).

julia> W=coxgroup(:A,3)
A₃

julia> cartan(W)
3×3 Matrix{Int64}:
  2  -1   0
 -1   2  -1
  0  -1   2

check_minimal_relation(gens,rel;verbose=false)

returns true iff the homogeneous relation prod(gens[rel[1]])==prod(gens[rel[2]]) is a minimal relation between gens (in particular, no left factor homogeneous relation holds), false otherwise. If verbose=true prints a description of failure.

coroot(r,λ=-1)

the coroot for a unitary reflection of root r and eigenvalue λ.

coroots(W,i) same as but better than coroots(W)[i]

coroots(W) the list of coroots of W (listed in the same order as the roots)

coxeter_number(W::PermRootGroup,i) or coxnum

Gordon and Griffeth GG2012 have defined the Coxeter number of an irreducible character φ of a complex reflection group as the scalar by which the central element ∑_{s in reflections(W)}(1-s) acts on the representation of character φ. The function coxnum returns the Coxeter number of the i-th irreducible character of W.

coxeter_number(W::PermRootGroup) or coxnum

Gordon and Griffeth GG2012 have defined the Coxeter number of an irreducible complex reflection group as the Coxeter number of its reflection character. It is also given by the formula (nref(W)+nhyp(W))/rank(W); for a well-generated group it is equal to the highest reflection degree. For a non-irreducible group, the Coxeter number is the sum of those of its irreducible components.

generic_order(W,q=Pol())

returns the generic order of W as a polynomial in q (the "compact" order of the Spets). This is $q^{Nₕ}Πᵢ(q^{dᵢ}-1)$ where dᵢ are the reflection degrees and Nₕ the number of reflecting hyperplanes. For a Weyl group, it is the order of the associated semisimple finite reductive group over the field with q elements.

julia> PermRoot.generic_order(complex_reflection_group(4),Pol(:q))
Pol{Int64}: q¹⁴-q¹⁰-q⁸+q⁴

inclusion(W::PermRootGroup)

the indices of the roots of W in the roots of parent(W).

inclusion(W::PermRootGroup,i::Integer) inclusion(W::PermRootGroup,v::AbstractVector{<:Integer})

same as inclusion(W)[i] or inclusion(W)[v] (but more efficient).

invariant_form(W::ComplexReflectionGroup)

This function returns the matrix F (defined up to a scalar) of an Hermitian form invariant under the action of the reflection group W. That is, if M is the matrix of an element of W, then M*F*M'=F.

julia> W=complex_reflection_group(4)
G₄

julia> invariant_form(W)
2×2 Matrix{Int64}:
 1  0
 0  2

invariants(W::ComplexReflectionGroup)

returns the fundamental invariants of W in its reflection representation V. That is, returns a set of algebraically independent elements of the symmetric algebra of the dual of V which generate the W-invariant polynomial functions on V. Each such invariant function is returned as a function: if e₁,…,eₙ is a basis of V and f is the function, then the value of the polynomial function on a₁e₁+…+aₙeₙ is obtained by calling f(a₁,…,aₙ). This function depends on the classification, and is dependent on the exact reflection representation of W. So for the moment it is only implemented when the reflection representation for the irreducible components has the same Cartan matrix as the one provided by Chevie for the corresponding irreducible group. The polynomials are invariant for the natural action of the group elements as matrices; that is, if m==reflrep(W,w) for some w in W, then an invariant f satisfies f(a₁,…,aₙ)=f(v₁,…,vₙ) where [v₁,…,vₙ]=[a₁,…,aₙ]×m. This action is implemented on Mvps by the function ^.

julia> W=coxgroup(:A,2)
A₂

julia> @Mvp x,y,z

julia> i=invariants(W);

julia> map(f->f(x,y),i)
2-element Vector{Mvp{Int64, Int64}}:
 -2x²+2xy-2y²
 6x²y-6xy²

julia> W=complex_reflection_group(24)
G₂₄

julia> p=invariants(W)[1](x,y,z)
Mvp{Rational{Int64}}: (14//1)x⁴+(-12//1)x²y²+(-42//1)x²yz+(21//2)x²z²+(18//7)y⁴+(-6//1)y³z+(-9//2)y²z²+(-21//8)z⁴

julia> map(v->^(v,reflrep(W,1);vars=[:x,:y,:z]),(x,y,z))
((1//2)x+(3√-7/14)y, (-√-7/2)x+(-1//2)y, z)

julia> p^reflrep(W,1)-p
Mvp{Cyc{Rational{Int64}}}: 0

isparabolic(W)

whether the reflection subgroup W is a parabolic subgroup of parent(W).

julia> W=complex_reflection_group(7)
G₇

julia> isparabolic(reflection_subgroup(W,[1,2]))
false

julia> isparabolic(reflection_subgroup(W,[1]))
true

number_of_hyperplanes(W::ComplexReflectionGroup) or nhyp(W)

The number of reflecting hyperplanes of W

number_of_reflections(W::ComplexReflectionGroup) or nref(W)

the number of reflections of W

parabolic_closure(W,I)

I should be a list of indices of reflections of W. Returns J such that reflection_subgroup(W,J) is the smallest parabolic subgroup of W containing reflection_subgroup(W,I).

julia> W=complex_reflection_group(7)
G₇

julia> parabolic_closure(W,[1])
1-element Vector{Int64}:
 1

julia> parabolic_closure(W,[1,2])
3-element Vector{Int64}:
 1
 2
 3

parabolic_reps(W)

For a Coxeter group or finite complex reflection group W, returns a list of indices of roots of W describing representatives of orbits of parabolic subgroups under conjugation by W. For Coxeter groups, each orbit has a representative which is a standard parabolic subgroup, that is whose indices is a subset of eachindex(gens(W)). This may not be the case in general.

julia> parabolic_reps(coxgroup(:A,4))
7-element Vector{Vector{Int64}}:
 []
 [1]
 [1, 2]
 [1, 3]
 [1, 2, 3]
 [1, 2, 4]
 [1, 2, 3, 4]

julia> parabolic_reps(complex_reflection_group(3,3,3))
7-element Vector{Vector{Int64}}:
 []
 [1]
 [1, 2]
 [1, 3]
 [1, 9]
 [2, 3]
 [1, 2, 3]

parabolic_reps(W,r)

If a second argument r is given, returns only representatives of the parabolic subgroups of semisimple rank r.

julia> parabolic_reps(coxgroup(:A,4),2)
2-element Vector{Vector{Int64}}:
 [1, 2]
 [1, 3]

julia> parabolic_reps(complex_reflection_group(3,3,3),2)
4-element Vector{Vector{Int64}}:
 [1, 2]
 [1, 3]
 [1, 9]
 [2, 3]

radical(G)

The radical datum of a root datum (X,Φ,Y,Φ^∨) is (X/(X∩ ℚ Φ),∅ ,Φ^⟂,∅), a toral datum. This function returns the torus corresponding to the radical of the root datum G.

rank(W::ComplexReflectionGroup)

returns the rank of W, which is the dimension of the space where it acts.

julia> rank(complex_reflection_group(31))
4

reflectionMatrix(r, ζ=-1)

returns the matrix of the unitary complex reflection determined by the root r and the eigenvalue ζ, that is, when the vector space and its dual are identified via the scalar product <x,y>=transpose(x)*y; the coroot rᵛ is then equal to the linear form x->(1-ζ)<x,r>/<r,r>.

julia> reflectionMatrix([1,0,-E(3,2)])
3×3 Matrix{Cyc{Rational{Int64}}}:
  0  0  ζ₃²
  0  1    0
 ζ₃  0    0

reflectionMatrix(root, coroot) the matrix of the reflection with a given root and coroot.

A (complex) reflection is a finite order element s of GL(V), the linear group of a vector space over a subfield of the complex numbers, whose fixed points form a hyperplane H (the reflecting hyperplane of s); an eigenvector r for the non-trivial eigenvalue ζ (a root of unity) is called a root of s. If we choose a linear form rᵛ defining H such that rᵛ(r)=1-ζ (a coroot of s) then s is given by x↦ x-rᵛ(x)r.

A way of specifying s is by giving a root and a coroot, which are uniquely determined by s up to multiplication of the root by a scalar and of the coroot by the inverse scalar. The function reflectionMatrix gives the matrix of the corresponding reflection in the standard basis of V, where the root and the coroot are vectors given in the standard bases of V and Vᵛ, so the pairing rᵛ(r) is obtained as transpose(root)*coroot.

julia> r=reflectionMatrix([1,0,0],[2,-1,0])
3×3 Matrix{Int64}:
 -1  0  0
  1  1  0
  0  0  1

julia> r==reflrep(coxgroup(:A,3),1)
true

julia> r*[2,-1,0]
3-element Vector{Int64}:
 -2
  1
  0

julia> [1 0 0]*r
1×3 Matrix{Int64}:
 -1  0  0

As we see in the last lines, in Julia a matrix operates from the right on the vector space V of row vectors and from the left on the dual space Vᵛ of column vectors.

reflection_character(W::ComplexReflectionGroup,w) or reflchar

Returns the trace of the element w of W as an endomorphism of the vector space V on which W acts.

julia> W=coxgroup(:B,3)
B₃

julia> reflchar(W,longest(W))
-3

reflection_character(W::ComplexReflectionGroup) or reflchar

Returns the reflection character of W. When W is irreducible, it is CharTable(W).irr[charinfo(W).extRefl[2]].

julia> reflchar(coxgroup(:A,3))
5-element Vector{Int64}:
  3
  1
 -1
  0
 -1

refleigen(W,i) faster than refleigen(W)[i]

reflection_eigenvalues(W) or refleigen(W)

Let W be a reflection group on the vector space V. reflection_eigenvalues(W) returns for each conjugacy class representative x of W (see classreps) the eigenvalues of x on V, as a list of Root1.

julia> refleigen(coxgroup(:B,2))
5-element Vector{Vector{Root1}}:
 [1, 1]
 [-1, 1]
 [-1, -1]
 [-1, 1]
 [ζ₄³, ζ₄]

reflection_representation(W,i::Integer) or reflrep(W,i)

the matrix for the distinguished reflection around the i-th root of W.

reflection_representation(W::ComplexReflectionGroup) or reflrep(W)

returns reflrep.(Ref(W),gens(W)), that is the generators of W as matrices.

reflection_representation(W::ComplexReflectionGroup,w) or reflrep(W,w)

Let V be the space on which W acts as a reflection group and let w∈ W, represented as a permutation of the roots. The function reflrep returns the matrix of w acting on V (recall that matrices operate from the right on a vector space in Chevie). This is the linear transformation of V which acts trivially on the orthogonal of the coroots and has same effect as w on the simple roots. The function makes sense more generally for a permutation of the roots induced by an element of GL(V) which stabilizes the roots (thus in particular normalizes W); thus it works for reflection cosets.

julia> W=reflection_subgroup(rootdatum("E7sc"),1:6)
E₇₍₁₂₃₄₅₆₎=E₆Φ₁

julia> reflrep(W,longest(W))
7×7 Matrix{Int64}:
  0   0   0   0   0  -1  2
  0  -1   0   0   0   0  2
  0   0   0   0  -1   0  3
  0   0   0  -1   0   0  4
  0   0  -1   0   0   0  3
 -1   0   0   0   0   0  2
  0   0   0   0   0   0  1

reflection_subgroup(W,r)

returns the reflection subgroup of the complex reflection group W generated by refls(W,r).

A reflection subgroup H of W is a permutation subgroup with the same additional information as W, and some new one added which express the relationship with the parent W:

inclusion(H): the indices of the roots of H in the roots of W

parent(H): is set to W.

restriction(H): a list of length length(roots(W)) with non-zero entries in positions inclusion(H) bound to eachindex(roots(H)).

A reflection group which is not a subgroup actually also has this information, set to the trivial values: inclusion(W)==restriction(W)==eachindex(roots(W)), and parent()==W. This allows a lot of code to be written in the same way for parent groups or reflection subgroups.

reflection_subgroup(R) where R is itself a reflection subgroup returns a reflection subgroup of the parent of R.

julia> W=coxgroup(:F,4)
F₄

julia> H=reflection_subgroup(W,[1,2,11,20])
F₄₍₉‚₂‚₁‚₁₆₎=D₄₍₃₂₁₄₎

julia> [restriction(H)]
1-element Vector{Vector{Int64}}:
 [1, 2, 0, 0, 5, 0, 0, 0, 3, 0  …  0, 16, 0, 19, 0, 21, 0, 22, 23, 24]

julia> reflection_subgroup(H,[1,2,3])
F₄₍₉₁₂₎=A₃₍₃₁₂₎Φ₁

refls(W::ComplexReflectionGroup,i)

the element of W representing the distinguished reflection around the i-th root of W (i can be an index or a vector of indices)

refls(W::ComplexReflectionGroup)

a list of same length as W.roots giving the corresponding element of W representing a distinguished reflection. In particular this list is much longer than unique(refls(W)) since in general there are several roots corresponding to a reflection.

restriction(W::PermRootGroup)

A list for each root of parent(W), which holds 0 if the root is not a root of W and i if the root is the i-th root of W.

restriction(W::PermRootGroup,i::Integer) restriction(W::PermRootGroup,v::AbstractVector{<:Integer})

same as restriction(W)[i] or restriction(W)[v] (but more efficient).

roots(W::PermRootGroup,i) same as roots(W)[i]

roots(W::PermRootGroup) the roots of W

semisimpleRank(W::ComplexReflectionGroup)

returns the semisimple rank of W, which is the dimension of the space where it effectively acts. If W is a reflection group on the space V, and V₁ is the subspace generated by roots(W), then semisimplerank(W) is the dimension of V₁. The reflection group W is called essential if V₁=V.

julia> W=reflection_subgroup(coxgroup(:A,3),[1,3])
A₃₍₁₃₎=A₁×A₁Φ₁

julia> semisimplerank(W)
2

julia> rank(W)
3

simple_conjugating(W,i)

an element w∈ W such that action(W,simple_reps(W,i),w)==i. In particular W(simple_reps(W,i))^simple_conjugating(W,i)==refls(W,i).

simple_conjugating(W::ComplexReflectionGroup)

For each index i of a root, an element w∈ W such that action(W,simple_reps(W,i),w)==i.

simple_reps(W,i)

the smallest index of a root in the same W-orbit as the i-th root (it is the index of a generator of W).

simple_reps(W)

for each root, the index of the first simple root conjugate to it (it is the index of a generator of W).

simplecoroots(W::ComplexReflectionGroup) the simple coroots of W (those corresponding to gens(W)) as a matrix (each coroot is a row)

simpleroots(W::ComplexReflectionGroup) the simple roots of W (those corresponding to gens(W)) as a matrix (each root is a row)

torus_order(W::ComplexReflectionGroup,i,q=Pol())

returns as a polynomial in q the toric order of the i-th conjugacy class of W. This is the characteristic polynomial of an element of that class on the reflection representation of W. It is the same as the generic order of the reflection subcoset torus(W,i) of W determined by the trivial subgroup and a representative of the i-th conjugacy class.

julia> W=complex_reflection_group(4)

julia> torus_order.(Ref(W),1:nconjugacy_classes(W),Pol(:q))
7-element Vector{Pol{Cyc{Int64}}}:
 q²-2q+1
 q²+2q+1
 q²+1
 q²-ζ₃q+ζ₃²
 q²+ζ₃q+ζ₃²
 q²+ζ₃²q+ζ₃
 q²-ζ₃²q+ζ₃

Let W be an irreducible CRG, generated by distinguished reflections S. type_irred classifies W (returns a type record) using:

• r=semisimplerank(W)
• s=length(W)/factorial(r)
• D=all distinguished reflections of W=orbit of S, which gives
• o=the maximum order of a reflection=max_{s∈ S}o(s)
• h=the Coxeter number=sum_{s∈ D}o(s)

G(de,e,r) has s=(de)ʳ/e, o=max(2,d), h=ed(r-1)+d-δ_{d,1}

(r,s,o) are sufficient to determine a G(de,e,r) excepted for ambiguity G(2e,e,2)/G(4e,4e,2), which is resolved by h (excepted for e=1, when the two solutions are isomorphic).

(r,s,o) are also sufficient to distinguish primitive groups except in the cases (which are resolved by h): G9/G(24,6,2) G12/G(12,6,2)/G(24,24,2) G13/G(24,12,2)/G(48,48,2) G22/G(60,30,2)/G(120,120,2) G7/G14/G(24,8,2) G8/G(12,3,2) G15/G(48,16,2) G17/G(120,24,2) G21/G(120,40,2)

unique_refls(W::ComplexReflectionGroup) A sublist of 1:length(roots(W)) such that the distinguished reflections around the corresponding roots reach one time only each distinguished reflection of W.

catalan(W::ComplexReflectionGroup)

returns the Catalan Number of the irreducible complex reflection group W. For well-generated groups, this number is equal to the number of simples in the dual Braid monoid. For other groups it was defined by Gordon and Griffeth2012. For Weyl groups, it also counts the number of antichains of roots.

julia> catalan(coxgroup(:A,7))
1430

catalan(W,i)

returns the i-th Fuss-Catalan Number of the irreducible complex reflection group W. For well-generated groups, this number is equal to the number of chains s₁,…,sᵢ of simples in the dual monoid where sⱼ divides sⱼ₊₁. For these groups, it is also equal to ∏ⱼ(ih+dⱼ)/dⱼ where the product runs over the reflection degrees of W, and where h is the Coxeter number of W. For non-well generated groups, the definition is in Gordon and Griffeth2012.

julia> catalan(complex_reflection_group(7),2)
16

catalan(W;q=1), resp. catalan(W,i;q=1)

for q a variable (like Pol() or an Mvp) returns the q-Catalan number (resp. the i-th q-Fuss Catalan number) of W. Again the definitions in general are in Gordon and Griffeth2012.

julia> catalan(complex_reflection_group(7),2;q=Pol())
Pol{Int64}: q⁷²+2q⁶⁰+3q⁴⁸+4q³⁶+3q²⁴+2q¹²+1

reflection_length(W::PermRootGroup,w::Perm) or reflength

This function returns the number of eigenvalues of w in the reflection representation which are not equal to 1. For a finite Coxeter group, this is equal to the reflection length of w, that is the minimum number of reflections of which w is a product. This also holds in general for a well-generated complex reflection group if w divides for the reflection length a Coxeter element.

julia> W=coxgroup(:A,4)
A₄

julia> reflength(W,longest(W))
2

julia> reflength(W,W(1,2,3,4))
4

This module contains functions for computing with unipotent elements of reductive groups; specifically to compute with elements of the unipotent radical of a Borel subgroup of a connected algebraic reductive group; these functions were initially written by Olivier Dudas in GAP3, partly inspired by older C code of Jean Michel.

The unipotent radical of a Borel subgroup is the product in any order of the root subgroups associated to the positive roots. We fix an order, which gives a canonical form to display elements and to compare them.

The computations use the Steinberg relations between root subgroups, which come from the choice of a Chevalley basis of the Lie algebra. The reference we follow is Carter1972, chapters 4 to 6.

We start with a root datum specified by a Weyl group W and build a struct UnipotentGroup which contains information about the maximal unipotent subgroup of the corresponding reductive group, that is the unipotent radical of the Borel subgroup determined by the positive roots.

julia> W=coxgroup(:E,6)
E₆

julia> U=UnipotentGroup(W)
UnipotentGroup(E₆)

Now, if α=roots(W,2), we construct the element u_α(4) of the root subgroup u_α:

julia> U(2=>4)
u2(4)

If we do not specify the coefficient we make by default u_α(1), so we have also:

julia> U(2)^4
u2(4)

We can make more complicated elements:

julia> U(2=>4)*U(4=>5)
u2(4)u4(5)

julia> U(2=>4,4=>5)
u2(4)u4(5)

If the roots are not in order the element is normalized:

julia> U(4=>5,2=>4)
u2(4)u4(5)u8(-20)

It is possible to display the decomposition of the roots in simple roots instead of their index:

julia> xdisplay(U(4=>5,2=>4);root=true)
u₀₁₀₀₀₀(4)u₀₀₀₁₀₀(5)u₀₁₀₁₀₀(-20)

The coefficients in the root subgroups can be elements of arbitrary rings. Here is an example using Mvp's:

julia> W=coxgroup(:E,8);U=UnipotentGroup(W)
UnipotentGroup(E₈)

julia> u=U(map(i->i=>Z(2)*Mvp(Symbol("x",Char(i+0x2080))),1:8)...)
u1(x₁)u2(x₂)u3(x₃)u4(x₄)u5(x₅)u6(x₆)u7(x₇)u8(x₈)

julia> cut(xrepr(u^16;limit=true,root=true),before="u",width=60)
u₂₂₃₄₃₂₁₀(x₁²x₂²x₃³x₄⁴x₅³x₆²x₇)
u₁₂₃₄₃₂₁₁(x₁x₂²x₃³x₄⁴x₅³x₆²x₇x₈)
u₁₂₂₄₃₂₂₁(x₁x₂²x₃²x₄⁴x₅³x₆²x₇²x₈)
u₁₂₂₃₃₃₂₁(x₁x₂²x₃²x₄³x₅³x₆³x₇²x₈)
u₂₂₃₄₃₂₁₁(x₁²x₂²x₃³x₄⁴x₅³x₆²x₇x₈)
u₁₂₂₄₃₃₂₁(x₁x₂²x₃²x₄⁴x₅³x₆³x₇²x₈)
u₁₂₂₄₄₃₂₁(x₁x₂²x₃²x₄⁴x₅⁴x₆³x₇²x₈)
u₂₂₃₄₃₃₂₁(x₁²x₂²x₃³x₄⁴x₅³x₆³x₇²x₈)
u₁₂₃₄₄₃₂₁(x₁x₂²x₃³x₄⁴x₅⁴x₆³x₇²x₈)
u₂₂₃₄₄₃₂₁(x₁²x₂²x₃³x₄⁴x₅⁴x₆³x₇²x₈)
u₂₃₃₅₄₃₂₁(x₁²x₂³x₃³x₄⁵x₅⁴x₆³x₇²x₈)
u₂₂₄₅₄₃₂₁(x₁²x₂²x₃⁴x₄⁵x₅⁴x₆³x₇²x₈)
u₂₃₄₆₅₄₃₂(x₁²x₂³x₃⁴x₄⁶x₅⁵x₆⁴x₇³x₈²)

julia> u^32
()

The above computation shows that in characteristic 2 the exponent of the unipotent group of E₈ is 32. More precisely, squaring doubles the height of the involved roots, so in the above u¹⁶ involves only roots of height 16 or more.

Various actions are defined on unipotent elements. Elements of the Weyl group act (through certain representatives) as long as no root subgroup is in their inversion set:

julia> W=coxgroup(:G,2)
G₂

julia> U=UnipotentGroup(W);@Mvp x,y

julia> u=U(1=>x,3=>y)
u1(x)u3(y)

julia> u^W(2,1)
u4(y)u5(x)

julia> u^W(1)
ERROR: u1(x)u3(y) should have no coefficient on root 1

Semisimple elements act by conjugation:

julia> s=SemisimpleElement(W,[E(3),2])
SemisimpleElement{Cyc{Int64}}: <ζ₃,2>

julia> u^s
u1(ζ₃x)u3(2ζ₃y)

As well as unipotent elements:

julia> u^U(2)
u1(x)u3(x+y)u4(-x-2y)u5(x+3y)u6(x²+3xy+3y²)

A struct UnipotentGroup represents the unipotent radical 𝐔 of a Borel subgroup of a reductive group G.

See Carter1972, section 4.2 for details on the following. A Chevalley basis of the Lie algebra of 𝐔 is a basis eᵣ, where each eᵣ is in the corresponding root subspace, such that [eᵣ,eₛ]=Nᵣₛ e_{r+s} for some integer constants Nᵣₛ. The constants Nᵣₛ for general roots are computed from the case where r and s are positive roots whose sum is a root; such a pair (r,s) is called special.

Constants Cᵣₛᵢⱼ are defined, see Carter1972, 5.2.3, by

$u_s(u)u_r(t)=u_r(t)u_s(u)\prod_{i,j>0}u_{ir+js}(C_{rsij}(-t)^iu^j)$

Where ir+js runs over the positive integral combinations of r and s which are roots, taken in lexicographic order on (i,j). The constants Cᵣₛᵢⱼ are computed from the constants Nᵣₛ, see Carter1972, bottom of page 61 and top of page 76.

The fields of struct Unipotent Group are:

• W: the Weyl group of G
• order: the total order on the roots used to normalize products of root subgroups (by default 1:nref(W))
• special: aNamedTuplefor each special pair of roots(r,s)`
• r index of r
• s index of s
• rs index of r+s
• N: the constant Nᵣₛ
• comm: stores the Cᵣₛᵢⱼ as the list of quadruples (i,j,ir+js,Cᵣₛᵢⱼ).

julia> U=UnipotentGroup(coxgroup(:G,2))
UnipotentGroup(G₂)

julia> U.special
10-element Vector{@NamedTuple{r::Int64, s::Int64, rs::Int64, N::Int64, comm::Vector{NTuple{4, Int64}}}}:
 (r = 1, s = 2, rs = 3, N = 1, comm = [(1, 1, 3, 1), (1, 2, 4, -1), (1, 3, 5, 1), (2, 3, 6, 2)])
 (r = 2, s = 3, rs = 4, N = 2, comm = [(1, 1, 4, 2), (2, 1, 5, 3), (1, 2, 6, -3)])
 (r = 2, s = 4, rs = 5, N = 3, comm = [(1, 1, 5, 3)])
 (r = 1, s = 5, rs = 6, N = 1, comm = [(1, 1, 6, 1)])
 (r = 3, s = 4, rs = 6, N = 3, comm = [(1, 1, 6, 3)])
 (r = 2, s = 1, rs = 3, N = -1, comm = [(1, 1, 3, -1), (2, 1, 4, -1), (3, 1, 5, -1), (3, 2, 6, -1)])
 (r = 3, s = 2, rs = 4, N = -2, comm = [(1, 1, 4, -2), (2, 1, 6, -3), (1, 2, 5, 3)])
 (r = 4, s = 2, rs = 5, N = -3, comm = [(1, 1, 5, -3)])
 (r = 5, s = 1, rs = 6, N = -1, comm = [(1, 1, 6, -1)])
 (r = 4, s = 3, rs = 6, N = -3, comm = [(1, 1, 6, -3)])

UnipotentGroup(W;chevalley=nothing,order=1:nref(W))

W should be a Weyl group. This function returns a struct UnipotentGroup associated to the reductive group of Weyl group W.

If the keyword order is given it is a total order on the positive roots used to normalize unipotent elements.

By default the structure constants Nᵣₛ are computed using the method of Carter72 from extraspecial pairs. Another set of structure constants can be given by given for the keyword chevalley a Dict associating to a pair (r,s) of root indices some object p such that first(p) is the corresponding N_{r,s}. Here is an example of using different constants from ChevLie.

julia> W=coxgroup(:G,2)
G₂

julia> using ChevLie: LieAlg, structconsts

julia> l=LieAlg(:g,2)
#I dim = 14
LieAlg('G2')

julia> U=UnipotentGroup(W;chevalley=structconsts(l))
#I calculating structconsts
#I calculating eps-canonical base (100/.) 
UnipotentGroup(G₂)

'U(r)'

'U(r1=>c1,..,r_n=>c_n)'

Where U is a UnipotentGroup. In the first form the function creates the element uᵣ(1), and in the second form the element u_{r_1}(c_1)… u_{r_n}(c_n)

julia> U=UnipotentGroup(coxgroup(:G,2))
UnipotentGroup(G₂)

julia> U(2)
u2(1)

julia> U(1=>2,2=>4)
u1(2)u2(4)

julia> U(2=>4,1=>2)
u1(2)u2(4)u3(-8)u4(32)u5(-128)u6(512)

decompose(w,u::UnipotentElement)

w should be an element of the Weyl group corresponding to u. If 𝐔 is the unipotent radical of the Borel subgroup determined by the positive roots, and 𝐔⁻ the opposite unipotent radical, this function decomposes u into its component in 𝐔 ∩ ʷ𝐔⁻ and its component in 𝐔 ∩ ʷ𝐔.

julia> W=coxgroup(:G,2)
G₂

julia> U=UnipotentGroup(W);@Mvp x,y

julia> u=U(2=>y,1=>x)
u1(x)u2(y)u3(-xy)u4(xy²)u5(-xy³)u6(2x²y³)

julia> decompose(W(1),u)
2-element Vector{UnipotentElement{Mvp{Int64, Int64}}}:
 u1(x)
 u2(y)u3(-xy)u4(xy²)u5(-xy³)u6(2x²y³)

julia> decompose(W(2),u)
2-element Vector{UnipotentElement{Mvp{Int64, Int64}}}:
 u2(y)
 u1(x)

'abelianpart(u::UnipotentElement)'

If 𝐔 is the unipotent subgroup and D(𝐔) its derived subgroup, this function returns the projection of the unipotent element 'u' on 𝐔/D(𝐔), that is its coefficients on the simple roots.

julia> U=UnipotentGroup(coxgroup(:G,2));@Mvp x,y

julia> u=U(2=>y,1=>x)
u1(x)u2(y)u3(-xy)u4(xy²)u5(-xy³)u6(2x²y³)

julia> abelianpart(u)
u1(x)u2(y)

'reorder(U,l[,order])'

This function takes a list of pairs 'r=>c' representing a unipotent element, where 'r' is a root and 'c' the corresponding coefficient, and puts it in canonical form, reordering the terms to agree with 'U.order' using the commutation relations. If a second argument is given, this is used instead of 'U.order'.

julia> U=UnipotentGroup(coxgroup(:G,2))
UnipotentGroup(G₂)

julia> l=reorder(U,[2=>4,1=>2])
6-element Vector{Pair{Int64, Int64}}:
 1 => 2
 2 => 4
 3 => -8
 4 => 32
 5 => -128
 6 => 512

julia> reorder(U,l,6:-1:1)
2-element Vector{Pair{Int64, Int64}}:
 2 => 4
 1 => 2

Finite Coxeter groups are the finite complex reflection groups which can be defined on a real vector space V.

Weyl groups are the finite Coxeter groups which can be defined over a rational vector space V (thus over the integers).

Like finite complex reflection groups, finite Coxeter groups are implemented as groups of permutations of a set of roots. The particular crystallographic root systems for Weyl groups play an important role in mathematics as they classify semi-simple Lie algebras and algebraic groups.

Let us give precise definitions. Let V be a real vector space and Vⱽ its dual. A root system is a finite set of vectors R⊂ V (the roots), together with a map r↦ rⱽ from R to a subset Rⱽ of Vⱽ (the coroots) such that:

• For any r∈ R, we have rⱽ(r)=2, so that the formula x↦ x-rⱽ(x)r defines a reflection sᵣ:V→ V with root r and coroot rⱽ.
• The reflection sᵣ stabilizes R.

The subgroup W=W(R) of GL(V) generated by the reflections sᵣ for r∈ R is a finite Coxeter group. We require reduced root systems, that is such that the only elements of R colinear with r∈ R are r and -r; for Weyl groups, we also require that the root system be crystallographic, that is rⱽ(s) is an integer, for any s∈ R,rⱽ∈ Rⱽ.

If we identify V with Vⱽ by choosing a W-invariant bilinear form (.;.), then we have rⱽ=2r/(r;r). A root system R is irreducible if R is not the union of two orthogonal subsets; equivalently the representation of W on the subspace generated by R is irreducible. If R is reducible then the corresponding Coxeter group is the direct product of the Coxeter groups associated with the irreducible components of R.

Let us now describe how a root system R and a presentation of the corresponding W are encoded in a Cartan matrix or a Dynkin diagram. We can choose a linear form on V which does not vanish on any element of R. Depending on the sign of the value of this linear form on a root r ∈ R we call r positive or negative. Then there exists a unique subset Π of the positive roots, the simple roots, such that any positive root is a linear combination with non-negative coefficients of the roots in Π. Any two sets of simple roots (corresponding to different choices of linear forms) can be transformed into each other by a unique element of W(R). If S is the set of reflections with respect to the simple roots, then (W,S) is a Coxeter system. These generating reflections are called Coxeter generators or simple reflections.

Since the pairing between V and Vⱽ is W-invariant, if Π is a set of simple roots and if we define the Cartan matrix as being the n times n matrix C={rⱽ(r')} for r,r'∈Π, this matrix is independent of the chosen linear form up to simultaneous permutation of rows and columns. Since the action of sᵣ on r' for r,r'∈Π is given by sᵣ(r')=r'-C(r,r')r, the Cartan matrix determines the reflection representation of W.

For a crystallographic root system the Cartan matrix has integral entries, and in the basis Π (completed by a basis of the orthogonal), sᵣ has an integral matrix. All finite-dimensional (complex) representations of a finite Coxeter group can be realized over the field generated by the entries of the Cartan matrix.

The Cartan matrix is encoded in a Dynkin diagram, a tree with weighted edges and an orientation on edges of even weight >2, as follows. The vertices are indexed by the simple reflections; an edge is drawn between s and t if the order mₛₜ of st is greater than 2 and is given the weight mₛₜ. These weights are encoded by drawing the edge single for weight 3, double for weight 4 and triple for weight 6. The arrows indicate the relative root lengths (going from the longer to the shorter root) which may differ between different orbits of W on R. Alternately the Dynkin diagram can be obtained from the Cartan matrix as follows: if Cᵣₛ and Cₛᵣ are integers such that |Cₛᵣ|≥|Cᵣₛ|=1 there is an edge of weight |Cₛᵣ| from r to s with an arrow pointing to s if |Cₛᵣ|>1. Note that the Cartan matrices we consider here are not necessarily symmetric, contrary to the Cartan matrices we considered describing the reflection representation of a general Coxeter group; being symmetric corresponds to all roots being taken of the same length.

The irreducible crystallographic root systems are classified by the following list of Dynkin diagrams. The labeling of the nodes is the order of the generators and is shown by the function diagram.

Aₙ O—O—O—…—O   Bₙ O⇐ O—O—…—O  Cₙ O⇒ O—O—…—O  Dₙ O 2
   1 2 3 … n      1  2 3 … n     1  2 3 … n     ￨
                                              O—O—…—O
                                              1 3 … n

G₂ O⇛ O  F₄ O—O⇒O—O    E₆  O 2    E₇  O 2      E₈  O 2
   1  2     1 2 3 4        ￨          ￨            ￨
                       O—O—O—O—O  O—O—O—O—O—O  O—O—O—O—O—O—O
                       1 3 4 5 6  1 3 4 5 6 7  1 3 4 5 6 7 8

We get the Coxeter diagram, which describes the underlying Weyl group, if we ignore the arrows: we see that the root systems B_n and C_n correspond to the same Coxeter group (the Coxeter diagram is defined by the Coxeter matrix). Weyl groups can also be characterized as the finite Coxeter groups such that all off-diagonal entries of the Coxeter matrix are in {2,3,4,6}.

Here are the Coxeter diagrams for the finite Coxeter groups which are not crystallographic (I₂(e) is not crystallographic if e∉ {2,3,4,6}).

       e        5         5
I₂(e) O—O   H₃ O—O—O  H₄ O—O—O—O
      1 2      1 2 3     1 2 3 4

The function cartan gives the cartan matrix for an irreducible root system

julia> cartan(:D,4)
4×4 Matrix{Int64}:
  2   0  -1   0
  0   2  -1   0
 -1  -1   2  -1
  0   0  -1   2

julia> cartan(:I,2,5) # for type I₂(e) give e as 3rd argument
2×2 Matrix{Cyc{Int64}}:
       2  ζ₅²+ζ₅³
 ζ₅²+ζ₅³        2

Given two Cartan matrices c1 and c2, their matrix direct sum (corresponding to the orthogonal direct sum of the root systems) can be obtained by cat(c1,c2,dims=[1,2]).

The whole root system can be recovered from the simple roots and the corresponding coroots, since each root is in the orbit of a simple root. The restriction of the simple reflections to the span of R is determined by the Cartan matrix, so R is determined by the Cartan matrix and the set of simple roots.

The function rootdatum takes as arguments a matrix r whose lines represents the list of simple roots and another matrix cr whose lines are the corresponding coroots and produces a FiniteCoxeterGroup. Such an object is a permutation group containing in addition the description of a root system. cr*transpose(r) should be a Cartan matrix. Each element of the coxeter group is represented as the permutation it induces on the roots, coded as a permutation of 1:2N where we label the positive roots by 1:N, and the negative roots by N+1:2N.

If a single matrix argument is given to rootdatum it is taken as cr and r is taken to be the identity matrix; we get thus a particular root system where the roots are the canonical basis of V. For convenience, rootdatum(cartan(t...)) can be simplified to coxgroup(t...).

julia> W=coxgroup(:D,4) # same as rootdatum(cartan(:D,4))
D₄

julia> cartan(W)
4×4 Matrix{Int64}:
  2   0  -1   0
  0   2  -1   0
 -1  -1   2  -1
  0   0  -1   2

Also, the FiniteCoxeterGroup associated to a direct sum of irreducible root systems can be obtained as

julia> W=coxgroup(:A,2)*coxgroup(:B,2)
A₂×B₂

julia> cartan(W) # same as cat(cartan(:A,2), cartan(:B,2),dims=[1,2])
4×4 Matrix{Int64}:
  2  -1   0   0
 -1   2   0   0
  0   0   2  -2
  0   0  -1   2

The elements of a Weyl group are permutations of the roots:

julia> W=coxgroup(:D,4)
D₄

julia> p=W(1,3,2,1,3) # permutes the 24 roots
(1,14,13,2)(3,17,8,18)(4,12)(5,20,6,15)(7,10,11,9)(16,24)(19,22,23,21)

julia> word(W,p)
5-element Vector{Int64}:
 1
 3
 1
 2
 3

finally, a benchmark on julia 1.0.2

julia> @btime length(elements(coxgroup(:E,7)))
  531.385 ms (5945569 allocations: 1.08 GiB)

GAP3 for the same computation takes 2.2s

coxeter_group(type,rank[,bond];sc=false) (or coxgroup)

If C=cartan(type,rank[,bond]), this is equivalent to rootdatum(C). If sc=true this is equivalent to rootdatum(permutedims(C),one(C)).

The resulting object W, a FiniteCoxeterGroup, has an additional entry compared to a PermRootGroup.

• W.rootdec: the root vectors, given as linear combinations of simple roots. The first nref(W) roots are positive, the next nref(W) are the corresponding negative roots. Moreover, the first semisimplerank(W) roots are the simple roots. The positive roots are ordered by increasing height.

and roots(W) is ordered is the same way as W.rootdec.

For how to get various information on the root system and the Coxeter group, see the functions nref, coroots, rootlengths, simple_reps, simple_conjugating, reflrep, simpleroots, simplecoroots, PermX, cartan, inclusion, restriction, action, rank, semisimplerank

In terms of root data, this function returns the adjoint root datum of Weyl group W. If sc=true it returns the simply connected root datum.

julia> W=coxgroup(:G,2)
G₂

julia> cartan(W)
2×2 Matrix{Int64}:
  2  -1
 -3   2

julia> W.rootdec
12-element Vector{Vector{Int64}}:
 [1, 0]
 [0, 1]
 [1, 1]
 [1, 2]
 [1, 3]
 [2, 3]
 [-1, 0]
 [0, -1]
 [-1, -1]
 [-1, -2]
 [-1, -3]
 [-2, -3]

julia> reflrep(W)
2-element Vector{Matrix{Int64}}:
 [-1 0; 1 1]
 [1 3; 0 -1]

coxeter_group() or coxgroup() the trivial Coxeter group

coxeter_matrix(type, rank [,bond]) or coxmat

Like cartan, the function coxmat can be defined from the type and rank of a finite Coxeter group.

inversions(W::FiniteCoxeterGroup, w::AbstractVector{<:Integer})

Given a word w=[s₁,…,sₙ] (a vector of integers) representing the element W(w...), returns the inversions of w, that is the list of indices of the reflections of W given by W(s₁), W(s₁,s₂,s₁), …, W(s₁,s₂,…,sₙ,sₙ₋₁,…,s₁).

julia> W=coxgroup(:A,3)
A₃

julia> inversions(W,[2,1,2])
3-element Vector{Int64}:
 2
 4
 1

cartan(type, rank [,bond])

the Cartan matrix for a finite Coxeter group described by type and rank. The recognized types are :A, :B, :Bsym, :C, :D, :E, :F, :Fsym, :G, :Gsym, :I, :H. For type :I a third argument must be given describing the bond between the two generators. The sym types correspond to (non-crystallographic) root systems where all roots have the same length; they afford automorphisms that the crystallographic root system does not afford, which allow to define the "very twisted" Chevalley groups.

julia> cartan(:F,4)
4×4 Matrix{Int64}:
  2  -1   0   0
 -1   2  -1   0
  0  -2   2  -1
  0   0  -1   2

julia> cartan(:I,2,5)
2×2 Matrix{Cyc{Int64}}:
       2  ζ₅²+ζ₅³
 ζ₅²+ζ₅³        2

julia> cartan(:Bsym,2)
2×2 Matrix{Cyc{Int64}}:
   2  -√2
 -√2    2

cartan(M::AbstractMatrix) Cartan matrix from Coxeter matrix

The argument should be the Coxeter matrix M for a Coxeter group W and the result is the Cartan Matrix C for the standard reflection representation of W. We have C[s,t]=-2cos(π/M[s,t]), where M[s,s]==1 and by convention π/M[s,t]==0 if M[s,t]==∞, which we represent by M[s,t]==0. Since M is symmetric, the resulting C is symmetric, meaning that all roots in the constructed reflection representation have same length.

julia> cartan([1 3;3 1])
2×2 Matrix{Cyc{Int64}}:
  2  -1
 -1   2

reflection_subgroup(W::FiniteCoxeterGroup,I)

For I⊆1:nref(W), the subgroup H of W generated by refls(W,I).

A theorem found independently by Deodhar1989 and Dyer1990 is that a subgroup H of a Coxeter system (W,S) generated by reflections has a canonical Coxeter generating set, formed of the t ∈ Ref(H) such length(W,tt')>length(W,t) for any t'∈ Ref(H) different from t. This is used by reflection_subgroup to determine the Coxeter system of H.

julia> W=coxgroup(:G,2)
G₂

julia> diagram(W)
O⇛ O G₂
1  2

julia> H=reflection_subgroup(W,[2,6])
G₂₍₂₆₎=Ã₁×A₁

julia> diagram(H)
O Ã₁
1
O A₁
2

The notation G₂₍₂₆₎ means that roots(W,[2,6]) is a system of simple roots for H.

If H is a standard parabolic subgroup of a Coxeter group W then the length function on H (with respect to its set of generators) is the restriction of the length function on W. This need not no longer be true for arbitrary reflection subgroups of W.

julia> elH=word.(Ref(H),elements(H))
4-element Vector{Vector{Int64}}:
 []
 [1]
 [2]
 [1, 2]

julia> elW=word.(Ref(W),elements(H))
4-element Vector{Vector{Int64}}:
 []
 [2]
 [1, 2, 1, 2, 1]
 [1, 2, 1, 2, 1, 2]

julia> map(w->H(w...),elH)==map(w->W(w...),elW)
true

We implement finite reflection groups as permutation groups on a set of roots. Consequently, a reflection subgroup H⊆ W is a permutation subgroup, thus its elements are represented as permutations of the roots of the parent group.

roots(C::AbstractMatrix)

returns the set of positive roots defined by the Cartan matrix C, which should be the Cartan matrix of a finite Coxeter group.

For an integer Cartan matrix, the returned roots are sorted by height and reverse lexicographically for a given height.

badprimes(W)

Let W be a Weyl group. A prime is bad for W if it divides a coefficient of some root on the simple roots. The function badprimes returns the list of primes which are bad for W.

julia> W=coxgroup(:E,8)
E₈

julia> badprimes(W)
3-element Vector{Int64}:
 2
 3
 5

derived_datum(G)

The derived datum of (X,Φ,Y,Φ^∨) is (X/Φ^{∨⟂}, Φ, Y∩ ℚ Φ^∨, Φ^∨) where ⟂ denotes the orthogonal. This function starts with a root datum object G and returns the root datum object corresponding to the derived datum.

describe_involution(W,w)

Given an involution w of a Coxeter group W, by a theorem of Richardson1982 there is a unique parabolic subgroup P of W such that P is finite and w is the longest element of P, and is central in P. The function returns I such that P==reflection_subgroup(W,I) and w==longest(reflection_subgroup(W,I)).

julia> W=coxgroup(:A,2)
A₂

julia> w=longest(W)
(1,5)(2,4)(3,6)

julia> describe_involution(W,w)
1-element Vector{Int64}:
 3

julia> w==longest(reflection_subgroup(W,[3]))
true

For now only works for finite Coxeter groups.

highest_short_root(W)

It is an error if W is not an irreducible Coxeter group. Otherwise HighestShortRoot returns the index of the unique short root of maximal height of W. If all roots have the same length then this is the index of the unique root of maximal height, equal to nref(W).

julia> W=coxgroup(:G,2)
G₂

julia> highest_short_root(W)
4

istorus(W) whether W is a torus

relative_group(W::FiniteCoxeterGroup,J)

J should be a if distinguished subset of S==eachindex(gens(W)), that is if for s∈ S-J we set $v(s,J)=w₀^{J∪ s}w₀ᴶ$ then J is stable by all v(s,J). Then $N_W(W_J)=W_J⋊ N₁$ where N₁ is the group generated by the v(s,J), which form a Coxeter system for N₁. Equivalently N₁ consists of the J-reduced elements of N_W(W_J). The quotient R=N_W(W_J)/W_J has a natural reflection representation on $X(ZL_J/ZG)$, using that by Lusztig1976, the images of the roots of W in $X(ZL_J)$ form a root system. The function returns R as a reflection group on $X(ZL_J/ZG)$, with some extra attributes reflecting its origin

• R.relative_indices=setdiff(S,J) in a certain order
• R.toparent= the list of v(s,J) corresponding to .relative_indices; defines an isomorphism R→ N₁.
• R.fromparent is a function mapping elements of N₁ to R. The inverse mapping to .toparent.

rootdatum(R::AbstractMatrix,CR::AbstractMatrix)

root datum from R whose rows are the simple roots on a basis of X(T) and CR whose rows are the simple coroots on a basis of Y(T). The following methods all define gl₃.

julia> rootdatum(:gl,3)==rootdatum("gl",3)
true

julia> rootdatum([1 -1 0;0 1 -1],[1 -1 0;0 1 -1])
A₂Φ₁

rootdatum(C::AbstractMatrix) adjoint root datum from Cartan matrix C. The adjoint group is also the default returned for coxeter_group(type,rank). The following methods all define pgl₃.

julia> rootdatum(cartan(:A,3))==coxgroup(:A,3)
true

julia> rootdatum(:pgl,3)
pgl₃

rootlengths(W::FiniteCoxeterGroup) the vector of the (squared) length of the roots of W. The shortest roots in an irreducible subsystem are given the length 1. In a Weyl group the others then have length 2 (or 3 in type G₂). The matrix of the W-invariant bilinear form is given by Diagonal(rootlengths(W)[1:ngens(W)])*cartan(W).

standard_parabolic(W,H)

Given a reflection subgroup H or the indices of its simple roots returns nothing if H is not parabolic, otherwise returns w such that H^w is a standard parabolic subgroup of W.

julia> W=coxgroup(:E,6)
E₆

julia> R=reflection_subgroup(W,[20,30,19,22])
E₆₍₁₉‚₁‚₉‚₂₀₎=A₄₍₃₁₂₄₎Φ₁²

julia> p=standard_parabolic(W,R)
(1,4,49,12,10)(2,54,62,3,19)(5,17,43,60,9)(6,21,34,36,20)(7,24,45,41,53)(8,65,50,15,22)(11,32,31,27,28)(13,48,46,37,40)(14,51,58,44,29)(16,23,35,33,30)(18,26,39,55,38)(42,57,70,72,56)(47,68,67,63,64)(52,59,71,69,66)

julia> p==standard_parabolic(W,[19,1,9,20]) # can give inclusiongens
true

julia> reflection_subgroup(W,[20,30,19,22].^p) # same as R^p
E₆₍₂₄₅₆₎=A₄Φ₁²

julia> R=reflection_subgroup(W,[1,2,3,5,6,35])
E₆₍₁‚₃‚₂‚₃₅‚₅‚₆₎=A₂₍₁₃₎×A₂₍₂₆₎×A₂₍₄₅₎

julia> standard_parabolic(W,R)

torus(rank::Integer)

This function returns the object corresponding to the notion of a torus of dimension rank, a Coxeter group of semisimple rank 0 and given rank. This corresponds to a split torus; the extension to Coxeter cosets is more useful.

julia> torus(3)
Φ₁³

two_tree(m)

Given a square matrix m with zeroes symmetric with respect to the diagonal, let G be the graph with vertices axes(m)[1] and an edge between i and j iff !iszero(m[i,j]).

If G is a line this function returns it as a Vector{Int}. If G is a tree with one vertex c of valence 3 the function returns (c,b1,b2,b3) where b1,b2,b3 are the branches from this vertex sorted by increasing length. Otherwise the function returns nothing.

This function is used when recognizing the type of a Cartan matrix.